/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

#include <sal/config.h>

#include <cassert>
#include <memory>
#include <mutex>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>

#include <dlfcn.h>

#include <rtl/strbuf.hxx>
#include <rtl/ustring.hxx>
#include <sal/log.hxx>
#include <typelib/typedescription.h>
#include <o3tl/string_view.hxx>

#include "rtti.hxx"
#include "share.hxx"

namespace {

class Generated {
public:
    virtual ~Generated() {};

    virtual std::type_info * get() const = 0;
};

class GeneratedPlain: public Generated {
public:
    GeneratedPlain(std::unique_ptr<std::type_info> && info): info_(std::move(info)) {};

    std::type_info * get() const override { return info_.get(); }

private:
    std::unique_ptr<std::type_info> info_;
};

class GeneratedPad: public Generated {
public:
    GeneratedPad(std::unique_ptr<char[]> && pad): pad_(std::move(pad)) {};

    ~GeneratedPad() override { get()->~type_info(); }

    std::type_info * get() const override final
    { return reinterpret_cast<std::type_info *>(pad_.get()); }

private:
    std::unique_ptr<char[]> pad_;
};

class RTTI
{
    typedef std::unordered_map< OUString, std::type_info * > t_rtti_map;

    t_rtti_map m_rttis;
    std::vector<OString> m_rttiNames;
    std::unordered_map<OUString, std::unique_ptr<Generated>> m_generatedRttis;

#if !defined ANDROID
    void * m_hApp;
#endif

public:
    RTTI();
    ~RTTI();

    std::type_info * getRTTI(typelib_TypeDescription const &);
};

RTTI::RTTI()
#if !defined ANDROID
    : m_hApp( dlopen( nullptr, RTLD_LAZY ) )
#endif
{
}

RTTI::~RTTI()
{
#if !defined ANDROID
    dlclose( m_hApp );
#endif
}

std::type_info * RTTI::getRTTI(typelib_TypeDescription const & pTypeDescr)
{
    OUString const & unoName = OUString::unacquired(&pTypeDescr.pTypeName);

    t_rtti_map::const_iterator iFind( m_rttis.find( unoName ) );
    if (iFind != m_rttis.end())
        return iFind->second;

    std::type_info * rtti;

    // RTTI symbol
    OStringBuffer buf( 64 );
    buf.append( "_ZTIN" );
    sal_Int32 index = 0;
    do
    {
        std::u16string_view token( o3tl::getToken(unoName, 0, '.', index ) );
        buf.append( static_cast<sal_Int32>(token.size()) );
        OString c_token( OUStringToOString( token, RTL_TEXTENCODING_ASCII_US ) );
        buf.append( c_token );
    }
    while (index >= 0);
    buf.append( 'E' );

    OString symName( buf.makeStringAndClear() );
#if !defined ANDROID
    rtti = static_cast<std::type_info *>(dlsym( m_hApp, symName.getStr() ));
#else
    rtti = static_cast<std::type_info *>(dlsym( RTLD_DEFAULT, symName.getStr() ));
#endif

    if (rtti)
    {
        std::pair< t_rtti_map::iterator, bool > insertion (
            m_rttis.insert( t_rtti_map::value_type( unoName, rtti ) ) );
        SAL_WARN_IF( !insertion.second, "bridges", "key " << unoName << " already in rtti map" );
        return rtti;
    }

    // try to lookup the symbol in the generated rtti map
    auto iFind2( m_generatedRttis.find( unoName ) );
    if (iFind2 != m_generatedRttis.end())
    {
        // taking already generated rtti
        rtti = iFind2->second->get();
        return rtti;
    }

    // we must generate it !
    // symbol and rtti-name is nearly identical,
    // the symbol is prefixed with _ZTI
    char const * rttiName = symName.getStr() +4;

    SAL_INFO("bridges", "Generated rtti for" << rttiName);

    std::unique_ptr<Generated> newRtti;
    switch (pTypeDescr.eTypeClass) {
    case typelib_TypeClass_EXCEPTION:
        {
            typelib_CompoundTypeDescription const & ctd
                = reinterpret_cast<
                    typelib_CompoundTypeDescription const &>(
                        pTypeDescr);
            if (ctd.pBaseTypeDescription)
            {
                // ensure availability of base
                std::type_info * base_rtti = getRTTI(
                    ctd.pBaseTypeDescription->aBase);
                m_rttiNames.emplace_back(OString(rttiName));
                std::unique_ptr<std::type_info> info(
                    new __cxxabiv1::__si_class_type_info(
                       m_rttiNames.back().getStr(), static_cast<__cxxabiv1::__class_type_info *>(base_rtti) ));
                newRtti.reset(new GeneratedPlain(std::move(info)));
            }
            else
            {
                // this class has no base class
                m_rttiNames.emplace_back(OString(rttiName));
                std::unique_ptr<std::type_info> info(
                    new __cxxabiv1::__class_type_info(m_rttiNames.back().getStr()));
                newRtti.reset(new GeneratedPlain(std::move(info)));
            }
            break;
        }
    case typelib_TypeClass_INTERFACE:
        {
            typelib_InterfaceTypeDescription const & itd
                = reinterpret_cast<
                   typelib_InterfaceTypeDescription const &>(
                        pTypeDescr);
            std::vector<std::type_info *> bases;
            for (sal_Int32 i = 0; i != itd.nBaseTypes; ++i) {
                bases.push_back(getRTTI(itd.ppBaseTypes[i]->aBase));
            }
            switch (itd.nBaseTypes) {
            case 0:
                {
                    m_rttiNames.emplace_back(OString(rttiName));
                    std::unique_ptr<std::type_info> info(
                        new __cxxabiv1::__class_type_info(
                            m_rttiNames.back().getStr()));
                    newRtti.reset(new GeneratedPlain(std::move(info)));
                    break;
                }
            case 1:
                {
                    m_rttiNames.emplace_back(OString(rttiName));
                    std::unique_ptr<std::type_info> info(
                        new __cxxabiv1::__si_class_type_info(
                            m_rttiNames.back().getStr(),
                            static_cast<
                                __cxxabiv1::__class_type_info *>(
                                    bases[0])));
                    newRtti.reset(new GeneratedPlain(std::move(info)));
                    break;
                }
            default:
                {
                    m_rttiNames.emplace_back(OString(rttiName));
                    auto pad = std::make_unique<char[]>(
                        sizeof (__cxxabiv1::__vmi_class_type_info)
                        + ((itd.nBaseTypes - 1)
                           * sizeof (
                               __cxxabiv1::__base_class_type_info)));
                    __cxxabiv1::__vmi_class_type_info * info
                       = new(pad.get())
                            __cxxabiv1::__vmi_class_type_info(
                                m_rttiNames.back().getStr(),
                                __cxxabiv1::__vmi_class_type_info::__flags_unknown_mask);
                    info->__base_count = itd.nBaseTypes;
                    for (sal_Int32 i = 0; i != itd.nBaseTypes; ++i)
                    {
                        info->__base_info[i].__base_type
                            = static_cast<
                                __cxxabiv1::__class_type_info *>(
                                    bases[i]);
                        info->__base_info[i].__offset_flags
                           = (__cxxabiv1::__base_class_type_info::__public_mask
                              | ((8 * i) << __cxxabiv1::__base_class_type_info::__offset_shift));
                    }
                    newRtti.reset(new GeneratedPad(std::move(pad)));
                    break;
                }
            }
            break;
        }
    default:
        assert(false); // cannot happen
    }
    rtti = newRtti->get();
    if (newRtti) {
        auto insertion (
            m_generatedRttis.emplace(unoName, std::move(newRtti)));
        SAL_WARN_IF( !insertion.second, "bridges", "key " << unoName << " already in generated rtti map" );
    }

    return rtti;
}

}

std::type_info * x86_64::getRtti(typelib_TypeDescription const & type) {
    static RTTI theRttiFactory;
    static std::mutex theMutex;
    std::lock_guard aGuard(theMutex);
    return theRttiFactory.getRTTI(type);
}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */