/++
The class finder parses D files and lists any classes defined inside.

It does not attempt to limit the search to Godot-related classes or expand
mixins; a completely accurate class list would require its own compiler or a
compiler plugin system for D to list the classes as they're compiled.
+/
module godot.tools.classfinder;

import godot.util.string;
import godot.util.classes;

import dparse.parser, dparse.lexer;
import dparse.ast;
import dparse.rollback_allocator;

import dsymbol.conversion : parseModuleSimple;

import std.file, std.path;
import std.string;
import std.range;
import std.meta;
import std.typecons : scoped;
import std.algorithm.iteration : joiner, map;
import std.conv : text;
import std.stdio : writeln, writefln;

size_t startLocation(in BaseNode node) {
    return node.tokens.front.index;
}

size_t endLocation(in BaseNode node) {
    return node.tokens.back.index;
}

/// A named scope such as a class or struct and its location in the file
struct ScopeRange {
    string name;
    enum Type {
        class_,
        struct_,
        template_
    }

    Type type;
    size_t start, end;
}

/// libdparse visitor to be used with a dsymbol-like simple parser
private class GDVisitor : ASTVisitor {
    FileInfo file;
    string[] moduleName;
    string overrideName; // manually set the class; TODO: not implemented yet
    size_t[2][] overrideAttributeRanges;

    ScopeRange[] scopeRanges;
    size_t[] classScopeRange; /// which ScopeRange each class corresponds to

    alias visit = ASTVisitor.visit;
    override void visit(in ModuleDeclaration m) {
        moduleName = m.moduleName.identifiers.map!(t => cast(string) t.text).array;
        super.visit(m);
    }

    // TODO: not implemented yet
    version (none) override void visit(in AtAttribute a) {
        import std.algorithm.searching : canFind;

        if (a.argumentList.items.canFind!(e => (cast(PrimaryExpression) e) && (
                cast(PrimaryExpression) e).primary.text == "MainClass")) {
            overrideAttributeRanges ~= [a.startLocation, a.endLocation];
        }
    }

    override void visit(in MixinTemplateName m) {
        import std.algorithm.searching;

        if (m.tokens.canFind!(t => t.text == "GodotNativeLibrary"))
            file.hasEntryPoint = true;
    }

    override void visit(in StructDeclaration s) {
        ScopeRange range = ScopeRange(s.name.text, ScopeRange.Type.struct_, s.startLocation, s
                .endLocation);
        scopeRanges ~= range;
    }

    override void visit(in InterfaceDeclaration i) {
        ScopeRange range = ScopeRange(i.name.text, ScopeRange.Type.struct_, i.startLocation, i
                .endLocation);
        scopeRanges ~= range;
    }

    override void visit(in ClassDeclaration c) {
        string name = c.name.text.dup;

        classScopeRange ~= scopeRanges.length;
        ScopeRange range = ScopeRange(name, ScopeRange.Type.class_, c.startLocation, c.endLocation);
        scopeRanges ~= range;

        file.classes ~= name;
        if (c.name.text.toLower == moduleName.back || c.name.text.camelToSnake == moduleName.back) {
            if (!file.mainClass.empty)
                writefln!"Module %s: found multiple classes matching the module name (%s and %s)"(
                    moduleName, file.mainClass, name);
            else
                file.mainClass = name;
        }

        super.visit(c);
    }
}

/// 
FileInfo parse(string path) {
    RollbackAllocator rba;
    StringCache stringCache = StringCache(StringCache.defaultBucketCount);

    ubyte[] bytes = cast(ubyte[]) std.file.read(path);

    LexerConfig lexerConfig;
    lexerConfig.fileName = path;
    auto tokens = getTokensForParser(bytes, lexerConfig, &stringCache);

    Module m;
    m = parseModuleSimple(tokens, path, &rba);

    auto visitor = new GDVisitor;
    visitor.file.name = path;
    // for root modules
    visitor.moduleName = [path.baseName.stripExtension];

    m.accept(visitor);
    visitor.file.moduleName = visitor.moduleName.joiner(".").text;
    if (visitor.file.mainClass.empty && visitor.file.classes.length == 1)
        visitor.file.mainClass = visitor.file.classes[0];

    foreach (ci, c; visitor.file.classes) {
        import std.algorithm : filter, multiSort, map;

        auto cScope = visitor.scopeRanges[visitor.classScopeRange[ci]];
        // names of the scopes that enclose cScope, outermost first
        auto parentScopeNames = visitor.scopeRanges
            .filter!(sr => sr.start <= cScope.start && sr.end >= cScope.end)
            .array
            .multiSort!((a, b) => a.start < b.start, (a, b) => a.end > b.end)
            .map!(sr => sr.name);

        visitor.file.classes[ci] = chain(only(visitor.file.moduleName), parentScopeNames).joiner(".")
            .text;
    }

    return visitor.file;
}