#include <gtest/gtest.h>
#include <Compiler/Resolver.h>

namespace {

using namespace clice;

std::vector<const char*> compileArgs = {
    "clang++",
    "-std=c++20",
    "main.cpp",
    "-resource-dir",
    "/home/ykiko/C++/clice2/build/lib/clang/20",
};

struct Visitor : public clang::RecursiveASTVisitor<Visitor> {
    clang::QualType result;
    std::unique_ptr<ParsedAST> parsedAST;

    Visitor(const char* code) : parsedAST(ParsedAST::build("main.cpp", code, compileArgs)) {}

    bool VisitTypeAliasDecl(clang::TypeAliasDecl* decl) {
        if(decl->getName() == "result") {
            auto type = decl->getUnderlyingType();
            {
                clang::Sema::CodeSynthesisContext context;
                context.Kind = clang::Sema::CodeSynthesisContext::TemplateInstantiation;
                context.Entity = decl;
                context.TemplateArgs = nullptr;
                parsedAST->sema.pushCodeSynthesisContext(context);
            }
            auto resolver = TemplateResolver(parsedAST->sema);
            result = resolver.resolve(type);
        }
        return true;
    }

    clang::QualType test() {
        auto decl = parsedAST->context.getTranslationUnitDecl();
        TraverseDecl(decl);
        return result;
    }
};

void match(clang::QualType type, std::string name, std::initializer_list<std::string> args) {
    auto TST = type->getAs<clang::TemplateSpecializationType>();
    ASSERT_TRUE(TST);
    ASSERT_EQ(TST->getTemplateName().getAsTemplateDecl()->getName(), name);

    auto template_args = TST->template_arguments();
    ASSERT_EQ(template_args.size(), args.size());

    auto iter = args.begin();
    for(auto arg: template_args) {
        auto T = llvm::dyn_cast<clang::TemplateTypeParmType>(arg.getAsType());
        ASSERT_TRUE(T);
        ASSERT_EQ(T->getDecl()->getName(), *iter);
        ++iter;
    }
}

TEST(DependentNameResolver, single_level_dependent_name) {
    const char* code = R"(
template <typename ...Ts>
struct type_list {};

template <typename T>
struct A {
    using type = type_list<T>;
};

template <typename X>
struct test {
    using result = typename A<X>::type;
};

)";
    Visitor visitor(code);
    auto result = visitor.test();
    match(result, "type_list", {"X"});
}

TEST(DependentNameResolver, multi_level_dependent_name) {
    const char* code = R"(
template <typename ...Ts>
struct type_list {};

template <typename T1>
struct A {
    using type = type_list<T1>;
};

template <typename T2>
struct B {
    using type = typename A<T2>::type;
};

template <typename T3>
struct C {
    using type = typename B<T3>::type;
};

template <typename X>
struct test {
    using result = typename C<X>::type;
};
)";
    Visitor visitor(code);
    clang::QualType result = visitor.test();

    match(result, "type_list", {"X"});
}

TEST(DependentNameResolver, dependent_dependent_dependent_name) {
    const char* code = R"(
 template <typename ...Ts>
 struct type_list {};

 template <typename T1>
 struct A {
     using self = A<T1>;
     using type = type_list<T1>;
 };

 template <typename X>
 struct test {
     using result = typename A<X>::self::self::self::self::self::type;
 };
)";
    Visitor visitor(code);
    clang::QualType result = visitor.test();

    match(result, "type_list", {"X"});
}

TEST(DependentNameResolver, alias_dependent_name) {
    const char* code = R"(
 template <typename ...Ts>
 struct type_list {};

 template <typename T1>
 struct A {
     using type = type_list<T1>;
 };

 template <typename T2>
 struct B {
     using base = A<T2>;
     using type = typename base::type;
 };

 template <typename X>
 struct test {
     using result = typename B<X>::type;
 };
)";
    Visitor visitor(code);
    clang::QualType result = visitor.test();
    result->dump();
    match(result, "type_list", {"X"});
}

//
// TEST(DependentNameResolver, alias_template_dependent_name) {
//     const char* code = R"(
// template <typename ...Ts>
// struct type_list {};
//
// template <typename T1>
// struct A {
//     using type = T1;
// };
//
// template <typename T2>
// struct B {
//     using base = A<T2>;
//     using type = type_list<typename base::type>;
// };
//
// template <typename X>
// struct test {
//     using result = typename B<X>::type;
// };
//)";
//     Visitor visitor(code);
//     clang::QualType result = visitor.test();
//
//     auto TST = result->getAs<clang::TemplateSpecializationType>();
//     ASSERT_TRUE(TST);
//     ASSERT_EQ(TST->getTemplateName().getAsTemplateDecl()->getName(), "type_list");
//
//     auto args = TST->template_arguments();
//     ASSERT_EQ(args.size(), 1);
//
//     auto T = llvm::dyn_cast<clang::TemplateTypeParmType>(args[0].getAsType());
//     ASSERT_TRUE(T);
//     ASSERT_EQ(T->getDecl()->getName(), "X");
// }
//
// TEST(DependentNameResolver, template_alias_dependent_name) {
//     const char* code = R"(
// template <typename ...Ts>
// struct type_list {};
//
// template <typename T1>
// struct A {
//     using type = type_list<T1>;
// };
//
// template <typename T2>
// using B = A<T2>;
//
// template <typename X>
// struct test {
//     using result = typename B<X>::type;
// };
//)";
//     Visitor visitor(code);
//     clang::QualType result = visitor.test();
//     // result->dump();
//     auto TST = result->getAs<clang::TemplateSpecializationType>();
//     ASSERT_TRUE(TST);
//     ASSERT_EQ(TST->getTemplateName().getAsTemplateDecl()->getName(), "type_list");
//
//     auto args = TST->template_arguments();
//     ASSERT_EQ(args.size(), 1);
//
//     auto T = llvm::dyn_cast<clang::TemplateTypeParmType>(args[0].getAsType());
//     ASSERT_TRUE(T);
//     ASSERT_EQ(T->getDecl()->getName(), "X");
// }
//
// TEST(DependentNameResolver, dependent_member_template) {
//     const char* code = R"(
// template <typename... Ts>
// struct type_list {};
//
// template <typename T1, typename U1>
// struct A {
//     using type = type_list<T1, U1>;
// };
//
// template <typename T2>
// struct B {
//     template <typename U2>
//     using type = typename A<T2, U2>::type;
// };
//
// template <typename X, typename Y>
// struct test {
//     using result = typename B<X>::template type<Y>;
// };
//)";
//     Visitor visitor(code);
//     clang::QualType result = visitor.test();
//     auto TST = result->getAs<clang::TemplateSpecializationType>();
//     ASSERT_TRUE(TST);
//     ASSERT_EQ(TST->getTemplateName().getAsTemplateDecl()->getName(), "type_list");
//
//     auto args = TST->template_arguments();
//     ASSERT_EQ(args.size(), 2);
//
//     auto X = llvm::dyn_cast<clang::TemplateTypeParmType>(args[0].getAsType());
//     ASSERT_TRUE(X);
//     ASSERT_EQ(X->getDecl()->getName(), "X");
//
//     auto Y = llvm::dyn_cast<clang::TemplateTypeParmType>(args[1].getAsType());
//     ASSERT_TRUE(Y);
//     ASSERT_EQ(Y->getDecl()->getName(), "Y");
// }
//
// TEST(DependentNameResolver, dependent_member_class_template) {
//     const char* code = R"(
// template <typename... Ts>
// struct type_list {};
//
// template <typename T1>
// struct A {
//     template <typename U1>
//     struct B {
//         using type = type_list<T1, U1>;
//     };
// };
//
// template <typename X, typename Y>
// struct test {
//     using result = typename A<X>::template B<Y>::type;
// };
//)";
//
//     Visitor visitor(code);
//     clang::QualType result = visitor.test();
//
//     auto TST = result->getAs<clang::TemplateSpecializationType>();
//     ASSERT_TRUE(TST);
//     ASSERT_EQ(TST->getTemplateName().getAsTemplateDecl()->getName(), "type_list");
//
//     auto args = TST->template_arguments();
//     ASSERT_EQ(args.size(), 2);
//
//     auto X = llvm::dyn_cast<clang::TemplateTypeParmType>(args[0].getAsType());
//     ASSERT_TRUE(X);
//     ASSERT_EQ(X->getDecl()->getName(), "X");
//
//     auto Y = llvm::dyn_cast<clang::TemplateTypeParmType>(args[1].getAsType());
//     ASSERT_TRUE(Y);
//     ASSERT_EQ(Y->getDecl()->getName(), "Y");
// }
//
// TEST(DependentNameResolver, dependent_partial_name) {
//     const char* code = R"(
// template <typename... Ts>
// struct type_list {};
//
// template <typename T1>
// struct A {};
//
// template <typename U2>
// struct B {};
//
// template <typename U2, template <typename...> typename HKT>
// struct B<HKT<U2>> {
//     using type = type_list<U2>;
// };
//
// template <typename X>
// struct test {
//     using result = typename B<A<X>>::type;
// };
//)";
//
//     Visitor visitor(code);
//     clang::QualType result = visitor.test();
//
//     // FIXME: resugar the result
// }
//
// TEST(DependentNameResolver, dependent_base_name) {
//     const char* code = R"(
// template <typename... Ts>
// struct type_list {};
//
// template <typename T1>
// struct A {
//     using type = type_list<T1>;
// };
//
// template <typename U2>
// struct B : A<U2> {};
//
// template <typename X>
// struct test {
//     using result = typename B<X>::type;
// };
//)";
//
//     Visitor visitor(code);
//     auto result = visitor.test();
//
//     auto TST = result->getAs<clang::TemplateSpecializationType>();
//     ASSERT_TRUE(TST);
//     ASSERT_EQ(TST->getTemplateName().getAsTemplateDecl()->getName(), "type_list");
//
//     auto args = TST->template_arguments();
//     ASSERT_EQ(args.size(), 1);
//
//     auto T = llvm::dyn_cast<clang::TemplateTypeParmType>(args[0].getAsType());
//     ASSERT_TRUE(T);
//     ASSERT_EQ(T->getDecl()->getName(), "X");
// }
//
//  TEST(DependentNameResolver, std_vector) {
//      const char* code = R"(
//  #include <vector>
//
//  template <typename T>
//  struct A {};
//
//  template <typename X>
//  struct test {
//      using result = typename std::vector<A<X>>::reference;
//  };
//)";
//
//      Visitor visitor(code);
//      clang::QualType result = visitor.test();
//      // result->dump();
//  }
//
//  TEST(DependentNameResolver, std_list) {
//      const char* code = R"(
//  #include <list>
//
//  template <typename T>
//  struct A {};
//
//  template <typename X>
//  struct test {
//      using result = typename std::list<A<X>>::reference;
//  };
//)";
//
//      Visitor visitor(code);
//      clang::QualType result = visitor.test();
//  }

}  // namespace