//===-- AppleObjCSymbolVendor.cpp -------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "AppleObjCTypeVendor.h"

#include "lldb/Core/Log.h"
#include "lldb/Core/Module.h"
#include "lldb/Expression/ASTDumper.h"
#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
#include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"

#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclObjC.h"

using namespace lldb_private;

class lldb_private::AppleObjCExternalASTSource : public ClangExternalASTSourceCommon
{
public:
    AppleObjCExternalASTSource (AppleObjCTypeVendor &type_vendor) :
        m_type_vendor(type_vendor)
    {
    }

    bool
    FindExternalVisibleDeclsByName (const clang::DeclContext *decl_ctx,
                                    clang::DeclarationName name)
    {
        static unsigned int invocation_id = 0;
        unsigned int current_id = invocation_id++;

        Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));  // FIXME - a more appropriate log channel?

        if (log)
        {
            log->Printf("AppleObjCExternalASTSource::FindExternalVisibleDeclsByName[%u] on (ASTContext*)%p Looking for %s in (%sDecl*)%p",
                        current_id,
                        static_cast<void*>(&decl_ctx->getParentASTContext()),
                        name.getAsString().c_str(), decl_ctx->getDeclKindName(),
                        static_cast<const void*>(decl_ctx));
        }

        do
        {
            const clang::ObjCInterfaceDecl *interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx);

            if (!interface_decl)
                break;

            clang::ObjCInterfaceDecl *non_const_interface_decl = const_cast<clang::ObjCInterfaceDecl*>(interface_decl);

            if (!m_type_vendor.FinishDecl(non_const_interface_decl))
                break;

            clang::DeclContext::lookup_const_result result = non_const_interface_decl->lookup(name);

            return (result.size() != 0);
        }
        while(0);

        SetNoExternalVisibleDeclsForName(decl_ctx, name);
        return false;
    }

    clang::ExternalLoadResult
    FindExternalLexicalDecls (const clang::DeclContext *DC,
                              bool (*isKindWeWant)(clang::Decl::Kind),
                              llvm::SmallVectorImpl<clang::Decl*> &Decls)
    {
        return clang::ELR_Success;
    }

    void
    CompleteType (clang::TagDecl *tag_decl)
    {
        static unsigned int invocation_id = 0;
        unsigned int current_id = invocation_id++;

        Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));  // FIXME - a more appropriate log channel?

        if (log)
        {
            log->Printf("AppleObjCExternalASTSource::CompleteType[%u] on (ASTContext*)%p Completing (TagDecl*)%p named %s",
                        current_id,
                        static_cast<void*>(&tag_decl->getASTContext()),
                        static_cast<void*>(tag_decl),
                        tag_decl->getName().str().c_str());

            log->Printf("  AOEAS::CT[%u] Before:", current_id);
            ASTDumper dumper((clang::Decl*)tag_decl);
            dumper.ToLog(log, "    [CT] ");
        }

        if (log)
        {
            log->Printf("  AOEAS::CT[%u] After:", current_id);
            ASTDumper dumper((clang::Decl*)tag_decl);
            dumper.ToLog(log, "    [CT] ");
        }
        return;
    }

    void
    CompleteType (clang::ObjCInterfaceDecl *interface_decl)
    {
        static unsigned int invocation_id = 0;
        unsigned int current_id = invocation_id++;

        Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));  // FIXME - a more appropriate log channel?

        if (log)
        {
            log->Printf("AppleObjCExternalASTSource::CompleteType[%u] on (ASTContext*)%p Completing (ObjCInterfaceDecl*)%p named %s",
                        current_id,
                        static_cast<void*>(&interface_decl->getASTContext()),
                        static_cast<void*>(interface_decl),
                        interface_decl->getName().str().c_str());

            log->Printf("  AOEAS::CT[%u] Before:", current_id);
            ASTDumper dumper((clang::Decl*)interface_decl);
            dumper.ToLog(log, "    [CT] ");
        }

        m_type_vendor.FinishDecl(interface_decl);

        if (log)
        {
            log->Printf("  [CT] After:");
            ASTDumper dumper((clang::Decl*)interface_decl);
            dumper.ToLog(log, "    [CT] ");
        }
        return;
    }

    bool
    layoutRecordType(const clang::RecordDecl *Record,
                     uint64_t &Size,
                     uint64_t &Alignment,
                     llvm::DenseMap <const clang::FieldDecl *, uint64_t> &FieldOffsets,
                     llvm::DenseMap <const clang::CXXRecordDecl *, clang::CharUnits> &BaseOffsets,
                     llvm::DenseMap <const clang::CXXRecordDecl *, clang::CharUnits> &VirtualBaseOffsets)
    {
        return false;
    }

    void StartTranslationUnit (clang::ASTConsumer *Consumer)
    {
        clang::TranslationUnitDecl *translation_unit_decl = m_type_vendor.m_ast_ctx.getASTContext()->getTranslationUnitDecl();
        translation_unit_decl->setHasExternalVisibleStorage();
        translation_unit_decl->setHasExternalLexicalStorage();
    }
private:
    AppleObjCTypeVendor                                    &m_type_vendor;
};

AppleObjCTypeVendor::AppleObjCTypeVendor(ObjCLanguageRuntime &runtime) :
    TypeVendor(),
    m_runtime(runtime),
    m_ast_ctx(runtime.GetProcess()->GetTarget().GetArchitecture().GetTriple().getTriple().c_str())
{
    m_external_source = new AppleObjCExternalASTSource (*this);
    llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> external_source_owning_ptr (m_external_source);
    m_ast_ctx.getASTContext()->setExternalSource(external_source_owning_ptr);
}

clang::ObjCInterfaceDecl*
AppleObjCTypeVendor::GetDeclForISA(ObjCLanguageRuntime::ObjCISA isa)
{
    ISAToInterfaceMap::const_iterator iter = m_isa_to_interface.find(isa);
    
    if (iter != m_isa_to_interface.end())
        return iter->second;
    
    clang::ASTContext *ast_ctx = m_ast_ctx.getASTContext();
    
    ObjCLanguageRuntime::ClassDescriptorSP descriptor = m_runtime.GetClassDescriptorFromISA(isa);
    
    if (!descriptor)
        return NULL;
    
    const ConstString &name(descriptor->GetClassName());
    
    clang::IdentifierInfo &identifier_info = ast_ctx->Idents.get(name.GetStringRef());

    clang::ObjCInterfaceDecl *new_iface_decl = clang::ObjCInterfaceDecl::Create(*ast_ctx,
                                                                                ast_ctx->getTranslationUnitDecl(),
                                                                                clang::SourceLocation(),
                                                                                &identifier_info,
                                                                                NULL);
    
    ClangASTMetadata meta_data;
    meta_data.SetISAPtr(isa);
    m_external_source->SetMetadata(new_iface_decl, meta_data);
    
    new_iface_decl->setHasExternalVisibleStorage();
    new_iface_decl->setHasExternalLexicalStorage();
    
    ast_ctx->getTranslationUnitDecl()->addDecl(new_iface_decl);
    
    m_isa_to_interface[isa] = new_iface_decl;
    
    return new_iface_decl;
}

class ObjCRuntimeMethodType
{
public:
    ObjCRuntimeMethodType (const char *types) : m_is_valid(false)
    {
        const char *cursor = types;
        enum ParserState {
            Start = 0,
            InType,
            InPos
        } state = Start;
        const char *type = NULL;
        int brace_depth = 0;
        
        uint32_t stepsLeft = 256;
        
        while (1)
        {
            if (--stepsLeft == 0)
            {
                m_is_valid = false;
                return;
            }
            
            switch (state)
            {
            case Start:
                {
                    switch (*cursor)
                    {
                    default:
                        state = InType;
                        type = cursor;
                        break;
                    case '\0':
                        m_is_valid = true;
                        return;
                    case '0': case '1': case '2': case '3': case '4':
                    case '5': case '6': case '7': case '8': case '9':
                        m_is_valid = false;
                        return;
                    }
                }
                break;
            case InType:
                {
                    switch (*cursor)
                    {
                    default:
                        ++cursor;
                        break;
                    case '0': case '1': case '2': case '3': case '4':
                    case '5': case '6': case '7': case '8': case '9':
                        if (!brace_depth)
                        {
                            state = InPos;
                            if (type)
                            {
                                m_type_vector.push_back(std::string(type, (cursor - type)));
                            }
                            else
                            {
                                m_is_valid = false;
                                return;
                            }
                            type = NULL;
                        }
                        else
                        {
                            ++cursor;
                        }
                        break;
                    case '[': case '{': case '(':
                        ++brace_depth;
                        ++cursor;
                        break;
                    case ']': case '}': case ')':
                        if (!brace_depth)
                        {
                            m_is_valid = false;
                            return;
                        }
                        --brace_depth;
                        ++cursor;
                        break;
                    case '\0':
                        m_is_valid = false;
                        return;
                    }
                }
                break;
            case InPos:
                {
                    switch (*cursor)
                    {
                    default:
                        state = InType;
                        type = cursor;
                        break;
                    case '0': case '1': case '2': case '3': case '4':
                    case '5': case '6': case '7': case '8': case '9':
                        ++cursor;
                        break;
                    case '\0':
                        m_is_valid = true;
                        return;
                    }
                }
                break;
            }
        }
    }
    
    clang::ObjCMethodDecl *BuildMethod (clang::ObjCInterfaceDecl *interface_decl, const char *name, bool instance)
    {
        if (!m_is_valid || m_type_vector.size() < 3)
            return NULL;
        
        clang::ASTContext &ast_ctx(interface_decl->getASTContext());
        
        clang::QualType return_qual_type;
        
        const bool isInstance = instance;
        const bool isVariadic = false;
        const bool isSynthesized = false;
        const bool isImplicitlyDeclared = true;
        const bool isDefined = false;
        const clang::ObjCMethodDecl::ImplementationControl impControl = clang::ObjCMethodDecl::None;
        const bool HasRelatedResultType = false;
        
        std::vector <clang::IdentifierInfo *> selector_components;
        
        const char *name_cursor = name;
        bool is_zero_argument = true;
        
        while (*name_cursor != '\0')
        {
            const char *colon_loc = strchr(name_cursor, ':');
            if (!colon_loc)
            {
                selector_components.push_back(&ast_ctx.Idents.get(llvm::StringRef(name_cursor)));
                break;
            }
            else
            {
                is_zero_argument = false;
                selector_components.push_back(&ast_ctx.Idents.get(llvm::StringRef(name_cursor, colon_loc - name_cursor)));
                name_cursor = colon_loc + 1;
            }
        }
        
        clang::Selector sel = ast_ctx.Selectors.getSelector(is_zero_argument ? 0 : selector_components.size(), selector_components.data());
        
        clang::QualType ret_type = BuildType(ast_ctx, m_type_vector[0].c_str());
        
        if (ret_type.isNull())
            return NULL;
        
        clang::ObjCMethodDecl *ret = clang::ObjCMethodDecl::Create(ast_ctx,
                                                                   clang::SourceLocation(),
                                                                   clang::SourceLocation(),
                                                                   sel,
                                                                   ret_type,
                                                                   NULL,
                                                                   interface_decl,
                                                                   isInstance,
                                                                   isVariadic,
                                                                   isSynthesized,
                                                                   isImplicitlyDeclared,
                                                                   isDefined,
                                                                   impControl,
                                                                   HasRelatedResultType);
        
        std::vector <clang::ParmVarDecl*> parm_vars;
        
        for (size_t ai = 3, ae = m_type_vector.size();
             ai != ae;
             ++ai)
        {
            clang::QualType arg_type = BuildType(ast_ctx, m_type_vector[ai].c_str());
            
            if (arg_type.isNull())
                return NULL; // well, we just wasted a bunch of time.  Wish we could delete the stuff we'd just made!

            parm_vars.push_back(clang::ParmVarDecl::Create(ast_ctx,
                                                           ret,
                                                           clang::SourceLocation(),
                                                           clang::SourceLocation(),
                                                           NULL,
                                                           arg_type,
                                                           NULL,
                                                           clang::SC_None,
                                                           NULL));
        }
        
        ret->setMethodParams(ast_ctx, llvm::ArrayRef<clang::ParmVarDecl*>(parm_vars), llvm::ArrayRef<clang::SourceLocation>());
        
        return ret;
    }
private:
    clang::QualType BuildType (clang::ASTContext &ast_ctx, const char *type)
    {
        if (!type)
            return clang::QualType();
        
        switch (*type)
        {
        default:
            return ast_ctx.UnknownAnyTy;
        case 'r':
            {
                clang::QualType target_type = BuildType(ast_ctx, type+1);
                if (target_type.isNull())
                    return clang::QualType();
                else if (target_type == ast_ctx.UnknownAnyTy)
                    return ast_ctx.UnknownAnyTy;
                else
                    return ast_ctx.getConstType(target_type);
            }
        case '^':
        {
            clang::QualType target_type = BuildType(ast_ctx, type+1);
            if (target_type.isNull())
                return clang::QualType();
            else if (target_type == ast_ctx.UnknownAnyTy)
                return ast_ctx.UnknownAnyTy;
            else
                return ast_ctx.getPointerType(target_type);
        }
        case 'c':
            return ast_ctx.CharTy;
        case 'i':
            return ast_ctx.IntTy;
        case 's':
            return ast_ctx.ShortTy;
        case 'l':
            if (ast_ctx.getTypeSize(ast_ctx.VoidTy) == 64)
                return ast_ctx.IntTy;
            else
                return ast_ctx.LongTy;
        case 'q':
            return ast_ctx.LongLongTy;
        case 'C':
            return ast_ctx.UnsignedCharTy;
        case 'I':
            return ast_ctx.UnsignedIntTy;
        case 'S':
            return ast_ctx.UnsignedShortTy;
        case 'L':
            if (ast_ctx.getTypeSize(ast_ctx.VoidTy) == 64)
                return ast_ctx.UnsignedIntTy;
            else
                return ast_ctx.UnsignedLongTy;
        case 'Q':
            return ast_ctx.UnsignedLongLongTy;
        case 'f':
            return ast_ctx.FloatTy;
        case 'd':
            return ast_ctx.DoubleTy;
        case 'B':
            return ast_ctx.BoolTy;
        case 'v':
            return ast_ctx.VoidTy;
        case '*':
            return ast_ctx.getPointerType(ast_ctx.CharTy);
        case '@':
            return ast_ctx.getObjCIdType();
        case '#':
            return ast_ctx.getObjCClassType();
        case ':':
            return ast_ctx.getObjCSelType();
        }
        return clang::QualType();
    }
    
    typedef std::vector <std::string> TypeVector;
    
    TypeVector  m_type_vector;
    bool        m_is_valid;
};

bool
AppleObjCTypeVendor::FinishDecl(clang::ObjCInterfaceDecl *interface_decl)
{
    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));  // FIXME - a more appropriate log channel?
    
    ClangASTMetadata *metadata = m_external_source->GetMetadata(interface_decl);
    ObjCLanguageRuntime::ObjCISA objc_isa = 0;
    if (metadata)
     objc_isa = metadata->GetISAPtr();
    
    if (!objc_isa)
        return false;
    
    if (!interface_decl->hasExternalVisibleStorage())
        return true;
    
    interface_decl->startDefinition();
    
    interface_decl->setHasExternalVisibleStorage(false);
    interface_decl->setHasExternalLexicalStorage(false);
    
    ObjCLanguageRuntime::ClassDescriptorSP descriptor = m_runtime.GetClassDescriptorFromISA(objc_isa);
    
    if (!descriptor)
        return false;
    
    auto superclass_func = [interface_decl, this](ObjCLanguageRuntime::ObjCISA isa)
    {
        clang::ObjCInterfaceDecl *superclass_decl = GetDeclForISA(isa);
        if (!superclass_decl)
            return;
        interface_decl->setSuperClass(superclass_decl);
    };
    
    auto instance_method_func = [log, interface_decl, this](const char *name, const char *types) -> bool
    {        
        if (!name || !types)
            return false; // skip this one

        ObjCRuntimeMethodType method_type(types);
        
        clang::ObjCMethodDecl *method_decl = method_type.BuildMethod (interface_decl, name, true);
        
        if (log)
            log->Printf("[  AOTV::FD] Instance method [%s] [%s]", name, types);
        
        if (method_decl)
            interface_decl->addDecl(method_decl);
        
        return false;
    };
    
    auto class_method_func = [log, interface_decl, this](const char *name, const char *types) -> bool
    {
        if (!name || !types)
            return false; // skip this one
        
        ObjCRuntimeMethodType method_type(types);
        
        clang::ObjCMethodDecl *method_decl = method_type.BuildMethod (interface_decl, name, false);
        
        if (log)
            log->Printf("[  AOTV::FD] Class method [%s] [%s]", name, types);
        
        if (method_decl)
            interface_decl->addDecl(method_decl);
        
        return false;
    };
    
    if (log)
    {
        ASTDumper method_dumper ((clang::Decl*)interface_decl);
        
        log->Printf("[AppleObjCTypeVendor::FinishDecl] Finishing Objective-C interface for %s", descriptor->GetClassName().AsCString());
    }
    
    
    if (!descriptor->Describe(superclass_func,
                              instance_method_func,
                              class_method_func,
                              std::function <bool (const char *, const char *, lldb::addr_t, uint64_t)> (nullptr)))
        return false;
    
    if (log)
    {
        ASTDumper method_dumper ((clang::Decl*)interface_decl);
        
        log->Printf("[AppleObjCTypeVendor::FinishDecl] Finished Objective-C interface");
        
        method_dumper.ToLog(log, "  [AOTV::FD] ");
    }
    
    return true;
}

uint32_t
AppleObjCTypeVendor::FindTypes (const ConstString &name,
                                bool append,
                                uint32_t max_matches,
                                std::vector <ClangASTType> &types)
{
    static unsigned int invocation_id = 0;
    unsigned int current_id = invocation_id++;
    
    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));  // FIXME - a more appropriate log channel?
    
    if (log)
        log->Printf("AppleObjCTypeVendor::FindTypes [%u] ('%s', %s, %u, )",
                    current_id,
                    (const char*)name.AsCString(),
                    append ? "true" : "false",
                    max_matches);
    
    if (!append)
        types.clear();
    
    uint32_t ret = 0;
    
    do
    {
        // See if the type is already in our ASTContext.
        
        clang::ASTContext *ast_ctx = m_ast_ctx.getASTContext();
        
        clang::IdentifierInfo &identifier_info = ast_ctx->Idents.get(name.GetStringRef());
        clang::DeclarationName decl_name = ast_ctx->DeclarationNames.getIdentifier(&identifier_info);
        
        clang::DeclContext::lookup_const_result lookup_result = ast_ctx->getTranslationUnitDecl()->lookup(decl_name);
        
        if (!lookup_result.empty())
        {
            if (const clang::ObjCInterfaceDecl *result_iface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(lookup_result[0]))
            {
                clang::QualType result_iface_type = ast_ctx->getObjCInterfaceType(result_iface_decl);
                
                if (log)
                {
                    ASTDumper dumper(result_iface_type);
                    
                    uint64_t isa_value = LLDB_INVALID_ADDRESS;
                    ClangASTMetadata *metadata = m_external_source->GetMetadata(result_iface_decl);
                    if (metadata)
                        isa_value = metadata->GetISAPtr();
                    
                    log->Printf("AOCTV::FT [%u] Found %s (isa 0x%" PRIx64 ") in the ASTContext",
                                current_id,
                                dumper.GetCString(),
                                isa_value);
                }
                    
                types.push_back(ClangASTType(ast_ctx, result_iface_type.getAsOpaquePtr()));
                ret++;
                break;
            }
            else
            {
                if (log)
                    log->Printf("AOCTV::FT [%u] There's something in the ASTContext, but it's not something we know about",
                                current_id);
                break;
            }
        }
        else if(log)
        {
            log->Printf("AOCTV::FT [%u] Couldn't find %s in the ASTContext",
                        current_id,
                        name.AsCString());
        }
        
        // It's not.  If it exists, we have to put it into our ASTContext.
                
        ObjCLanguageRuntime::ObjCISA isa = m_runtime.GetISA(name);
    
        if (!isa)
        {
            if (log)
                log->Printf("AOCTV::FT [%u] Couldn't find the isa",
                            current_id);
            
            break;
        }
        
        clang::ObjCInterfaceDecl *iface_decl = GetDeclForISA(isa);
        
        if (!iface_decl)
        {
            if (log)
                log->Printf("AOCTV::FT [%u] Couldn't get the Objective-C interface for isa 0x%" PRIx64,
                            current_id,
                            (uint64_t)isa);
            
            break;
        }
        
        clang::QualType new_iface_type = ast_ctx->getObjCInterfaceType(iface_decl);
        
        if (log)
        {
            ASTDumper dumper(new_iface_type);
            log->Printf("AOCTV::FT [%u] Created %s (isa 0x%" PRIx64 ")",
                        current_id,
                        dumper.GetCString(),
                        (uint64_t)isa);
        }
        
        types.push_back(ClangASTType(ast_ctx, new_iface_type.getAsOpaquePtr()));
        ret++;
        break;
    } while (0);
    
    return ret;
}