import {Singleton, Instantiable, Inject} from "../../di"
import {Collection} from "../../util"
import {CommandLineApplication} from "./CommandLineApplication"
import {Directive} from "../Directive"
import {Template} from "../Template"
import {directive_template} from "../templates/directive"
import {unit_template} from "../templates/unit";
import {controller_template} from "../templates/controller";
import {middleware_template} from "../templates/middleware";
import {routes_template} from "../templates/routes";
import {config_template} from "../templates/config";
import {Unit} from "../../lifecycle/Unit";
import {Logging} from "../../service/Logging";

/**
 * Service for managing directives, templates, and other resources related
 * to the command line utilities.
 */
@Singleton()
export class CommandLine extends Unit {
    @Inject()
    protected readonly logging!: Logging

    /** Directive classes registered with the CLI command. */
    protected directives: Collection<Instantiable<Directive>> = new Collection<Instantiable<Directive>>()

    /** Templates registered with the CLI command. These can be created with the TemplateDirective. */
    protected templates: Collection<Template> = new Collection<Template>()

    constructor() { super() }

    async up() {
        this.registerTemplate(directive_template)
        this.registerTemplate(unit_template)
        this.registerTemplate(controller_template)
        this.registerTemplate(middleware_template)
        this.registerTemplate(routes_template)
        this.registerTemplate(config_template)
    }

    /**
     * Returns true if the application was started from the command line.
     */
    public isCLI() {
        return this.app().hasUnit(CommandLineApplication)
    }

    /**
     * Returns a string containing the Extollo ASCII logo.
     */
    public getASCIILogo() {
        return `     _       
    / /\\       ______      _        _ _
   / /  \\     |  ____|    | |      | | |
  / / /\\ \\    | |__  __  _| |_ ___ | | | ___
 / / /\\ \\ \\   |  __| \\ \\/ / __/ _ \\| | |/ _ \\
/ / /  \\ \\_\\  | |____ >  <| || (_) | | | (_) |
\\/_/    \\/_/  |______/_/\\_\\\\__\\___/|_|_|\\___/
`
    }

    /**
     * Register a Directive class with this service. This will make
     * the directive available for use on the CLI.
     * @param directiveClass
     */
    public registerDirective(directiveClass: Instantiable<Directive>) {
        if ( !this.directives.includes(directiveClass) ) {
            this.directives.push(directiveClass)
        }
    }

    /**
     * Returns true if the given directive is registered with this service.
     * @param directiveClass
     */
    public hasDirective(directiveClass: Instantiable<Directive>) {
        return this.directives.includes(directiveClass)
    }

    /**
     * Get a collection of all registered directives.
     */
    public getDirectives() {
        return this.directives.clone()
    }

    /**
     * Register the given template with this service. This makes the template
     * available for use with the TemplateDirective service.
     * @param template
     */
    public registerTemplate(template: Template) {
        if ( !this.templates.firstWhere('name', '=', template.name) ) {
            this.templates.push(template)
        } else {
            this.logging.warn(`Duplicate template will not be registered: ${template.name}`)
            this.logging.debug(`Duplicate template registered at: ${(new Error()).stack}`)
        }
    }

    /**
     * Returns true if a template with the given name exists.
     * @param name
     */
    public hasTemplate(name: string) {
        return !!this.templates.firstWhere('name', '=', name)
    }

    /**
     * Returns the template with the given name, if one exists.
     * @param name
     */
    public getTemplate(name: string): Template | undefined {
        return this.templates.firstWhere('name', '=', name)
    }

    /**
     * Get a collection of all registered templates.
     */
    public getTemplates() {
        return this.templates.clone()
    }
}