import * as vscode from 'vscode';

export enum InputType {
    binary_hsd = "binary_hsd",
    image = "image",
    csv_cartesiam = "csv_cartesiam",
    csv_unico = "csv_unico",
    csv_sensortile = "csv_sensortile"
}

export enum ModelType {
    classifier = "classifier",
    anomaly_detector = "anomaly_detector",
    predictor = "predictor"

}

export enum OutputType {
    openmv_stm32_bin = "openmv_stm32_bin",
    mlc = "mlc",
    full_stm32_bin = "stm32_bin",
    partial_stm32_bin = "partial_stm32_bin",
    openmv_stm32_upython ="openmv_stm32_upython",
    cartesiam = "cartesiam",
    octonion = "octonion",
    stred_bin = "stred_bin",
    mp1_greengrass_lambda = "mp1_greengrass_lambda",
    mp1_azure_iot_edge = "mp1_azure_iot_edge",
    mp1_azure_iot_coral_tpu = "mp1_azure_iot_coral_tpu",
    full_spc5_bin = "full_spc5_bin",
    partial_spc5_bin = "partial_spc5_bin"
}

export enum Stage {
    input = "input",
    model = "model",
    output = "output"
}

export enum TrainingType {
    offline = "offline",
    online = "online"
}

export enum ModelStage {
    definition = "definition",
    input = "log_collection",
    modeling = "modeling",
    deployed = "deployed",
    validation = "validation"
}

export class Tool {
    constructor(
        public readonly name: string,
        public readonly version: string,
        public readonly parameters: any
    ) {}

    public static deserialize(tool: any) : Tool {
        return new Tool(tool.name, tool.version, tool.parameters);
    }

}

export class Test {
    constructor(
        public readonly uuid: string,
        public readonly name: string,
        public readonly best: boolean,
        public readonly modelFile: string | null,
        public readonly reports: Array<string>,
        public readonly outputs: Array<string>,
    ) {}

    public static deserialize(test: any, best: boolean) : Test {
        return new Test(test.uuid, test.name, best, test.model_file, test.reports, test.outputs);
    }
}

export class Experiment {
    constructor(
        public readonly uuid: string,
        public readonly name: string,
        public readonly description: string,
        public readonly modelDevFile: string,
        public readonly tests: Array<Test>
    ) {}

    public static deserialize(experiment: any, tests: Array<Test>) : Experiment {
        return new Experiment(experiment.uuid, experiment.name, experiment.comments, experiment.model_dev_file, tests);
    }

}

export class Log {
    constructor(
        public readonly uuid: string,
        public readonly name: string,
        public readonly time: string
    ) {}

    public static deserialize(log: any) : Log {
        return new Log(log.uuid, log.name, log.start_time);
    }

}

export class Input {
    constructor(
        public readonly uuid: string,
        public readonly type: InputType,
        public readonly augmentation: Array<string>,
        public readonly tools: Array<Tool>,
        public readonly logs: Array<Log>
    ) {}

    public static deserialize(input: any) : Input {
        const logs: Array<Log> = input.logs.map((l:any) => Log.deserialize(l));
        const tools: Array<Tool> = input.tools.map((t:any) => Tool.deserialize(t));
        return new Input(input.uuid, <InputType> input.input_type, input.augmentation,tools, logs);
    }
}

export class Output {
    constructor(
        public readonly uuid: string,
        public readonly type: OutputType,
        public readonly tools: Array<Tool>
    ) {} 

    public static deserialize(output: any) : Output {
        const tools: Array<Tool> = output.tools.map( (t:any) => Tool.deserialize(t) )
        return new Output(output.uuid, <OutputType> output.output_type, tools);
    }
}

export class Model {
    constructor(
        public readonly uuid: string,
        public readonly name: string,
        public readonly stage: ModelStage,
        public readonly type: ModelType,
        public readonly metadata: any,
        public readonly input: Input,
        public readonly output: Output,
        public readonly experiments: Array<Experiment>
    ) {}

    public static deserialize(model: any, input: Input, output: Output, experiments: Array<Experiment>) : Model {
        return new Model(model.uuid, model.name, <ModelStage>model.stage, <ModelType> model.model_type, model.model_metadata, input, output, experiments);
    }
}

export class Project {
    constructor(
        public readonly rawProject: any,
        public readonly uuid: string,
        public readonly name: string,
        public readonly description: string,
        public readonly version: string,
        public readonly models: Array<Model>,
        public readonly uri: vscode.Uri
    ) {}

    public static deserialize(p : any, uri: vscode.Uri) : Project {

        const models : Array<Model> = p.models.map( 
            (model:any) => { 
                const experiments : Array<Experiment> = [];
                const input : Input = Input.deserialize(p.inputs.find( (i:any) => i.model_ref == model.uuid ));
                const rawOutput : any = p.outputs.find( (o:any) => o.model_ref == model.uuid );
                const output : Output = Output.deserialize(rawOutput);
                model.experiments.forEach( (e:any) => {
                    const tests : Array<Test> = rawOutput.tests
                        .filter( (t : any) => t.experiment_ref == e.uuid)
                        .map( (t: any) => new Test(t.uuid, t.name, t.uuid == rawOutput.best_test, t.model_file, t.reports, t.outputs) );
                    experiments.push(new Experiment(e.uuid, e.name,e.description, e.model_dev_file, tests));
                });
               return Model.deserialize(model, input, output, experiments);
            }
        );

        return new Project(p, p.uuid, p.ai_project_name, p.description, p.version, models, uri);
    }

    public serialize() : any { return this.rawProject; }
}

/**
 * @abstract @class IProjectManager
 * 
 * @description Project manager exposes methods to handle an Edge.AI project data model 
 * 
 * @param onDidChangeProject Event fired when concrete project change
 * @param rawProject Raw project data model
 * @param project Deserialized project data model
 * @param uri URI identifying the current project
 */
export abstract class IProjectManager {

    public uri: vscode.Uri;

    abstract connect(uri: any): any;

    abstract load(): any;

    abstract newProject(projectId: string | undefined, name: string, description: string, owner: string, version: string): any;

    abstract addModel(modelId: string, inputId: string, outputId: string, name: string, stage: ModelStage, inputType: InputType, modelType: ModelType, outputType: OutputType, trainingType: TrainingType, modelMetadata: any, inputTools: Tool[], outputTools: Tool[]): any;

    abstract updateModel(modelId: string, description: string | undefined, stage: ModelStage | undefined, classes: string[] | undefined, augmentations: string[]): any;

    abstract removeModel(modelId: string): any;

    abstract addExperiment(modelId: string, experimentId: string, name: string, description: string, modelDevFile: string | null): any;

    abstract updateExperiment(modelId: string, experimentId: string, description: string, modelDevFile: string | null): any;

    abstract removeExperiment(modelId: string, experimentId: string): any;

    abstract addTest(modelId: string, experimentId: string, testId: string | undefined, name: string, modelFile: string | null): any;

    abstract updateTest(modelId: string, testId: string, parameters: any, reports: string[] | undefined, outputs: string[] | undefined, isBest: boolean | undefined): any;

    abstract removeTest(modelId: string, experimentId: string, testId: string): any;

    constructor(public backendBaseUrl: vscode.Uri){
        this.uri = vscode.Uri.parse("");
    }
}