import { Observable } from "@hibas123/utils";
import { ConsoleAdapter } from "./consolewriter";
import inspect from "./inspect";
import { Adapter, LoggingTypes, Message, FormatConfig, DefaultFormatConfig, Format, FormatTypes, Colors, FormattedText, FormattedLine } from "./types";

export function removeColors(text: string) {
    text = text.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");

    // let index = text.indexOf("\x1b");
    // while (index >= 0) {
    //     text = text.substring(0, index) + text.substring(index + 5, text.length);
    //     index = text.indexOf("\x1b");
    // }
    return text;
}

export interface LoggingBaseOptions {
    /**
     * Name will be prefixed on Console output and added to logfiles, if not specified here
     */
    name: string,
    /**
     * Prints output to console
     */
    console: boolean;
}

export class LoggingBase {

    private _formatMap: FormatConfig = new DefaultFormatConfig();

    public set formatMap(value: FormatConfig) {
        this._formatMap = value;
    }


    private adapter = new Set<Adapter>();
    private adapter_init: Promise<void>[] = [];

    private messageObservable = new Observable<Message>();
    protected _name: string;


    private _logLevel = LoggingTypes.Debug;

    get logLevel() {
        return this._logLevel;
    }

    set logLevel(value: LoggingTypes) {
        this._logLevel = value;
    }

    get name() {
        return this._name;
    }

    constructor(options?: Partial<LoggingBaseOptions> | string) {
        let opt: Partial<LoggingBaseOptions>;
        if (!options) opt = {}
        else if (typeof options === "string") {
            opt = { name: options };
        } else {
            opt = options;
        }

        let config: LoggingBaseOptions = {
            name: undefined,
            console: true,
            ...opt
        };

        if (config.name)
            this._name = config.name;

        for (let key in this) {
            if (typeof this[key] === "function") this[key] = (<any>this[key]).bind(this);
        }

        if (config.console) {
            this.addAdapter(new ConsoleAdapter());
        }


        //Binding function to this
        this.debug = this.debug.bind(this);
        this.log = this.log.bind(this);
        this.warn = this.warn.bind(this);
        this.warning = this.warning.bind(this);
        this.error = this.error.bind(this);
        this.errorMessage = this.errorMessage.bind(this);
        this.flush = this.flush.bind(this);
    }

    addAdapter(adapter: Adapter) {
        if (!this.adapter.has(adapter)) {
            this.adapter.add(adapter);
            let prms = Promise.resolve(adapter.init(this.messageObservable.getPublicApi(), this._name));
            this.adapter_init.push(prms);
        }
    }

    flush(sync: true): void;
    flush(sync: false): Promise<void>;
    flush(sync: boolean): void | Promise<void> {
        if (sync) {
            this.adapter.forEach(elm => elm.flush(true));
        } else {
            let adapters: (void | Promise<void>)[] = [];
            this.adapter.forEach(elm => adapters.push(elm.flush(false)));
            return Promise.all(adapters).then(() => { });
        }
    }

    public close() {
        this.adapter.forEach(adapter => adapter.close ? adapter.close() : undefined);
    }

    public waitForSetup() {
        return Promise.all(this.adapter_init);
    }

    debug(...message: any[]) {
        if (this._logLevel <= LoggingTypes.Debug)
            this.message(LoggingTypes.Debug, message);
    }

    log(...message: any[]) {
        if (this._logLevel <= LoggingTypes.Log)
            this.message(LoggingTypes.Log, message);
    }

    warning(...message: any[]) {
        if (this._logLevel <= LoggingTypes.Warning)
            this.message(LoggingTypes.Warning, message);
    }

    warn(...message: any[]) {
        if (this._logLevel <= LoggingTypes.Warning)
            this.message(LoggingTypes.Warning, message);
    }

    error(error: Error | string) {
        if (this._logLevel > LoggingTypes.Error)
            return;
        if (!error) error = "Empty ERROR was passed, so no informations available";
        if (typeof error === "string") {
            let e = new Error("This is a fake error, to get a stack trace");
            this.message(LoggingTypes.Error, [error, "\n", e.stack]);
        } else {
            this.message(LoggingTypes.Error, [error.message, "\n", error.stack], getCallerFromExisting(error));
        }
    }

    errorMessage(...message: any[]) {
        if (this._logLevel <= LoggingTypes.Error)
            this.message(LoggingTypes.Error, message);
    }

    private message(type: LoggingTypes, message: any[], caller?: { file: string, line: number }) {
        let date = new Date().toISOString().replace(/T/, ' ').replace(/\..+/, '');

        let file_raw = caller || getCallerFile();
        let file = `${file_raw.file}:${String(file_raw.line).padEnd(3, " ")}`;

        let type_str = LoggingTypes[type].toUpperCase().padEnd(5, " ");
        let type_format: Format[] = [];
        switch (type) {
            case LoggingTypes.Log:
                type_format = this._formatMap.log;
                break;
            case LoggingTypes.Error:
                type_format = this._formatMap.error;
                break;
            case LoggingTypes.Debug:
                type_format = this._formatMap.debug;
                break;
            case LoggingTypes.Warning:
                type_format = this._formatMap.warning;
                break;
        }

        const prefix: FormattedText[] = [];
        const a = (text: string, formats: Format[] = []) => {
            prefix.push({
                text,
                formats
            })
        }

        a("[");
        a(date, this._formatMap.date);
        a("][");
        a(type_str, type_format);
        if (file_raw.file) {
            a("][");
            a(file, this._formatMap.file);
        }
        a("]: ");


        let raw: string[] = [];

        const formatted: FormattedLine[] = [];
        let line: FormattedLine;
        const newLine = () => {
            if (line && line.length > 0) {
                formatted.push(line);
                raw.push(line.map(e => e.text).join(""));
            }
            line = [...prefix];
        }
        newLine();

        message.forEach((e, i) => {
            let formats: Format[] = [];
            if (typeof e !== "string") {
                if (typeof e === "object") {
                    if (e[colorSymbol]) {
                        formats.push({
                            type: FormatTypes.COLOR,
                            color: e[colorSymbol]
                        })
                        e = e.value;
                    }
                }
                if (typeof e !== "string")
                    e = inspect(e, { colors: true, showHidden: true, depth: 3 }) as string;
            }

            removeColors(e).split("\n").map((text, index, { length }) => {
                line.push({ text, formats });
                if (index < length - 1) {
                    newLine();
                }
            })

            if (!e.endsWith("\n") && i < message.length - 1) {
                line.push({ text: " ", formats: [] });
            }
        });

        newLine();

        let msg: Message = {
            date: new Date(),
            file,
            name: this._name,
            text: {
                raw,
                formatted
            },
            type
        }

        this.messageObservable.send(msg);
    }
}

const colorSymbol = Symbol("color");

export interface ColorFormat {
    [colorSymbol]: Colors;
    value: any;
}

export function withColor(color: Colors, value: any): ColorFormat {
    return {
        [colorSymbol]: color,
        value
    }
}

function getStack() {
    // Save original Error.prepareStackTrace
    let origPrepareStackTrace = (<any>Error).prepareStackTrace;

    // Override with function that just returns `stack`
    (<any>Error).prepareStackTrace = function (_, stack) {
        return stack
    }

    // Create a new `Error`, which automatically gets `stack`
    let err = new Error();

    // Evaluate `err.stack`, which calls our new `Error.prepareStackTrace`
    let stack: any[] = <any>err.stack;

    // Restore original `Error.prepareStackTrace`
    (<any>Error).prepareStackTrace = origPrepareStackTrace;

    // Remove superfluous function call on stack
    stack.shift(); // getStack --> Error

    return stack
}

function baseName(path) {
    return path.split(/[\\/]/).pop();
}

function getCallerFile() {
    try {
        let stack = getStack()

        let current_file = stack.shift().getFileName();

        while (stack.length) {
            let caller_file = stack.shift();
            if (current_file !== caller_file.getFileName())
                return {
                    file: baseName(caller_file.getFileName()),
                    line: caller_file.getLineNumber()
                };
        }
    } catch (err) { }
    return { file: undefined, line: 0 };
}

function getCallerFromExisting(err: Error): { file: string, line: number } {
    if (!err || !err.stack) return { file: "NOFILE", line: 0 };
    let lines = err.stack.split("\n");
    lines.shift();// removing first line
    while (lines.length > 0) {
        let line = lines.shift();
        let matches = line.match(/[a-zA-Z_-]+[.][a-zA-Z_-]+[:][0-9]+/g)
        if (matches && matches.length > 0) {
            let [f, line] = matches[0].split(":")
            return {
                file: f, line: Number(line)
            };
        }
    }
}