import { createProgram, JsxEmit, Program } from 'typescript';
import { join } from 'path';
import { SourceFile } from './SourceFile';

export class Project {
    private program: Program;
    private knownFiles: Record<string, SourceFile> = {};

    constructor(private projectFolder: string) {
        const rootFile = join(
            this.projectFolder,
            'src/components/index.ts',
        );

        this.program = createProgram([rootFile], {
            // these options are the same as the ones in tsconfig.json
            allowJs: true,
            jsx: JsxEmit.React,
        });
    }

    public getSourceFile(fileName: string) {
        if (!(fileName in this.knownFiles)) {
            const file = this.program.getSourceFile(join(
                this.projectFolder,
                fileName,
            ));
            if (file) {
                this.knownFiles[fileName] = new SourceFile(file);
            }
        }

        return this.knownFiles[fileName] ?? null;
    }

    // ... some additional logic could be here
}

import {
    isArrayTypeNode,
    isTypeAliasDeclaration,
    isTypeLiteralNode,
    isIntersectionTypeNode,
    isUnionTypeNode,
    isPropertySignature,
    ArrayTypeNode,
    factory,
    TypeNode,
    TypeReferenceNode,
    TypeAliasDeclaration,
    TypeLiteralNode,
    TypeElement,
    IntersectionTypeNode,
    UnionTypeNode,
} from 'typescript';
import debug from 'debug';

import { Project } from './Project';
import { SourceFile } from './SourceFile';

const MAX_TRAVERSE_DEPTH = 10;

type ContextType = {
    depthLevel: number;
    file: SourceFile;
};

const d = debug('Crawler');

export class Crawler {
    constructor(private project: Project) {}

    public crawl(
        fileName: string,
    ) {
        const sourceFile = this.project.getSourceFile(fileName);
        if (sourceFile) {
            this.traverse(sourceFile, {
                depthLevel: 0,
                file: sourceFile,
            });
        }
    }

    private traverse(node: TypeNode, ctx: ContextType): TypeNode {
        const { depthLevel } = ctx;

        if (depthLevel > MAX_TRAVERSE_DEPTH) {
            return node;
        }

        if (isArrayTypeNode(node)) {
            return this.traverseArrayType(node, ctx);
        }

        if (isTypeAliasDeclaration(node)) {
            return this.traverseTypeAlias(node, ctx);
        }

        if (isTypeLiteralNode(node)) {
            return this.traverseTypeLiteral(node, ctx);
        }

        if (isIntersectionTypeNode(node)) {
            return this.traverseIntersectionType(node, ctx);
        }

        if (isUnionTypeNode(node)) {
            return this.traverseUnionType(node, ctx);
        }

        // some other cases to process

        return node;
    }

    private traverseTypeLiteral(node: TypeLiteralNode, ctx: ContextType) {
        const { members } = node;

        const result: TypeElement[] = [];

        for (let i = 0; i < members.length; i += 1) {
            const member = members[i];

            if (isPropertySignature(member)) {
                if (member.type) {
                    const updatedMember = factory.updatePropertySignature(
                        member,
                        member.modifiers,
                        member.name,
                        member.questionToken,
                        this.traverse(
                            member.type,
                            this.dive(ctx),
                        ),
                    );

                    // jsDoc falls out after being processed through factory.updatePropertySignature(). Putting it back again
                    // @ts-ignore
                    updatedMember.jsDoc = member.jsDoc;

                    result.push(updatedMember);
                }
            } else {
                result.push(member);
            }
        }

        return factory.createTypeLiteralNode(result);
    }

    private traverseArrayType(node: ArrayTypeNode, ctx: ContextType) {
        const { elementType } = node;

        const processedElementType = this.traverse(elementType, ctx);

        const unionOrIntersection =
            isUnionTypeNode(processedElementType) ||
            isIntersectionTypeNode(processedElementType);

        return factory.createArrayTypeNode(
            unionOrIntersection
                ? factory.createParenthesizedType(processedElementType)
                : processedElementType,
        );
    }

    private traverseIntersectionType(
        node: IntersectionTypeNode,
        ctx: ContextType,
    ) {
        const members = node.types;

        const result: TypeNode[] = [];
        for (let i = 0; i < members.length; i += 1) {
            result.push(this.traverse(members[i], this.dive(ctx)));
        }

        return factory.updateIntersectionTypeNode(
            node,
            factory.createNodeArray(result),
        );
    }

    private traverseUnionType(node: UnionTypeNode, ctx: ContextType) {
        const members = node.types;

        const result: TypeNode[] = [];
        for (let i = 0; i < members.length; i += 1) {
            result.push(this.traverse(members[i], this.dive(ctx)));
        }

        return factory.updateUnionTypeNode(
            node,
            factory.createNodeArray(result),
        );
    }

    private traverseTypeAlias(node: TypeAliasDeclaration, ctx: ContextType) {
        const { type } = node;

        return this.traverse(type, this.dive(ctx));
    }

    private dive(
        ctx: ContextType,
        file?: SourceFile,
    ): ContextType {
        let result = {
            ...ctx,
            depthLevel: ctx.depthLevel + 1,
        };

        if (file) {
            result = {
                ...result,
                file,
            };
        }

        return result;
    }
}