import { Body, Injectable } from '@nestjs/common';
import axios, { Axios, AxiosResponse } from 'axios';
import { readFile, writeFile } from 'node:fs/promises';
import { response } from 'express';
import { json } from 'node:stream/consumers';
import math, { create, all, evaluate, number, random, complex, string, SQRT1_2 } from 'mathjs';
import { ClickhouseService } from 'src/database/clickhouse/clickhouse.service';
import { classToPlain } from 'class-transformer';



@Injectable()
export class MetricK2 {
    id: string;
    name: string;
    type: string;
    addr: string;
    value: number;
    description: string;
    status: number;
    device: number;
    source: string;
};

@Injectable()
export class K2Metrics {
    service_name: string;
    // device: number;
    // source: string;
    //endpoint_name: string;
    metrics: MetricK2[];
};

@Injectable()
export class RangeValues {
    min: number;
    max: number;
    status: number;
};

@Injectable()
export class MetricsRanges {
    name: string;
    ranges: RangeValues[];
};

@Injectable()
export class ComplexMetricsCalculation {
    id: string;
    name: string;
    values: string;
    formula: string;
};

var prev: K2Metrics; //Prevous K2


@Injectable()
export class ZvksmetricsService {
    async useStatusModel(inputData: any): Promise<any> {
        let inp: K2Metrics = new K2Metrics();
        inp = inputData;

        let complex: K2Metrics = new K2Metrics();
        complex.service_name = inputData.service_name;
        complex.metrics = [];

        let model: ComplexMetricsCalculation[] = [];
        model = await this.setComplexMetrics();

        let scope: MetricsRanges[] = [];
        scope = await this.setMetricsRanges();

        if (!prev) {
            prev = inp;
        }
        // console.log(prev);

        let intermediate = await this.getComplexMetricsValues(inp, prev, complex, model, scope);

        console.log(intermediate);
        let ctp: any = classToPlain(intermediate);
        let copmplexParameterBody: string = JSON.stringify(ctp);
        let rtp: any = classToPlain(inputData);
        let rawParameterBody: string = JSON.stringify(rtp);
        // console.log(parameterBody);
        let abc = new ClickhouseService();
        await abc.ClickHouseAddRecords('raw', rawParameterBody);
        await abc.ClickHouseAddRecords('complex', copmplexParameterBody);


        // const val = JSON.parse(JSON.stringify(model[0].values));

        // let editedMetrics : K2Metrics = await this.getMetrics (inp, comlexCalc, scope);
        let responseFromExporter: any = await this.sendMetrics(intermediate);
        let responseFromExporter1: any = await this.sendMetrics(inp);

        prev = inp;

        return responseFromExporter;

    }

    async getMetrics(inputData: K2Metrics, scope: MetricsRanges[]): Promise<K2Metrics> {
        let arr: MetricK2[] = inputData.metrics;
        let length: number = arr.length;

        for (let i = 0; i < length; i++) {
            arr[i].status = await this.setMetricsStatus(arr[i], scope);
        }
        inputData.metrics = arr;

        return inputData;
    }

    // async getComplexMetrics(complexData: K2Metrics, scope: MetricsRanges[]): Promise<K2Metrics> {
    //     let arr: MetricK2[] = complexData.metrics;
    //     let length: number = arr.length;

    //     for (let i = 0; i < length; i++) {
    //         arr[i].status = await this.setMetricsStatus(arr[i], scope);
    //     }
    //     complexData.metrics = arr;

    //     return complexData;
    // }

    async getComplexMetricsValues(inputData: K2Metrics, prevousData: K2Metrics, complexData: K2Metrics, complexCalc: ComplexMetricsCalculation[], scope: MetricsRanges[]): Promise<K2Metrics> {
        let length: number = complexCalc.length;
        let metrics: MetricK2[] = complexData.metrics;

        let devices: number[] = [18, 19];
        let device_len: number = devices.length;

        // const jsonData = require('../conf/devices.json');  
        // console.log(jsonData); 
        for (let d = 0; d < device_len; d++) {
            for (let i = 0; i < length; i++) {
                let metr = { "source": "" };
                let val = await this.setComplexMetricValue(complexCalc[i].values, complexCalc[i].formula, inputData.metrics, prevousData.metrics, devices[d], metr);
                if (val != null || val != undefined) {
                    let complexMetric = new MetricK2();
                    complexMetric.id = complexCalc[i].id;
                    complexMetric.name = complexCalc[i].name;
                    complexMetric.type = inputData.metrics[0].type;
                    complexMetric.addr = inputData.metrics[0].addr;
                    complexMetric.value = val;
                    complexMetric.description = complexCalc[i].name;
                    complexMetric.status = await this.showStatus(scope, complexMetric.name, val);
                    complexMetric.device = devices[d];
                    complexMetric.source = metr.source;
                    metrics.push(complexMetric);
                }
            }
        }

        // console.log(complexData.metrics);

        return complexData;
    }

    async setComplexMetricValue(value: string, formula: string, currMetrics: MetricK2[], prevMetrics: MetricK2[], device: number, obj: any): Promise<any> {
        const val = JSON.parse(JSON.stringify(value));
        let arr = val.arr;
        // let dev = currMetrics.find(element => element.id == "measure_1217")?.id;
        // console.log(dev);
        let arr_len: number = arr.length;
        obj.source = currMetrics.find(element => element.name == arr[0] && element.device == device)?.source;
        // console.log(obj.source);

        for (let i = 0; i < arr_len; i++) {
            let temp = arr[i];
            arr[i] = currMetrics.find(element => element.name == arr[i] && element.device == device)?.value;

            // if(!arr[i]){
            // console.log(arr[i], temp, device);
            //     arr[i]=0;
            // }
        }
        let prevarr = val.prevarr;
        if (prevarr) {
            let prevarr_len: number = prevarr.length;
            for (let i = 0; i < prevarr_len; i++) {
                let temp1 = prevarr[i];
                prevarr[i] = prevMetrics.find(element => element.name == prevarr[i] && element.device == device)?.value;
                // console.log(prevarr[i], temp1, device);
            }
        }

        // console.log(obj.soure);
        try {
            let result: number = evaluate(formula, val);
            // console.log(result);
            return result;
            // console.log(result);
        } catch {
            return null;
        }
    }

    async setMetricsStatus(metric: MetricK2, scope: MetricsRanges[]): Promise<number> {
        if (metric && scope) {
            return await this.showStatus(scope, metric.name, metric.value);
        }
        else {
            return 5;
        }
    }

    async sendMetrics(inputData: K2Metrics): Promise<string> {
        let resp: any;
        let path: string = 'http://192.168.2.34:9050/update';
        let body: any = JSON.stringify(inputData);
        let options: any = {
            headers: { 'Content-Type': 'application/json' }
        };

        await axios.post(path, body, options).then((response) => {
            resp = response.status + ' ' + response.data;
            // console.log(resp);
        }).catch((error) => {
            resp = error;
        });

        return resp;
    }

    async showStatus(scope: MetricsRanges[], metricName: string, metricValue: number): Promise<number> {
        let status: number = 0;
        let test: any = scope.find(element => element.name == metricName);
        if (test) {
            let range: MetricsRanges = test;
            let transit: any = range.ranges.find(element => element.min <= metricValue && metricValue <= element.max)?.status;
            if (transit) {
                status = transit;
                return status;
            }
            else {
                return 0;
            }
        }
        return status;
    }

    async setMetricsRanges(@Body() rangesData: any = null): Promise<MetricsRanges[]> {
        let url: string = 'http://192.168.2.39:9999/api/ranges/9999';
        let options: any = {
            headers: { 'Content-Type': 'application/json' }
        };

        await axios.options(url, options).then((response) => {
            rangesData = response.data;
        }).catch((error) => {
            rangesData = error;
        });
        // console.log(rangesData);
        return rangesData;
    }

    async saveRanges(inputRanges: string): Promise<any> {
        let ret: any;
        let filePath = './src/zvksmetrics/conf/ranges.json';
        console.log(inputRanges);
        let inp: string = JSON.stringify(inputRanges);
        try {
            await writeFile(filePath, inp);
            ret = "200 OK";
        }
        catch {
            ret = "Error write file";
            console.log(ret);
        }
        return ret;
    }

    async setComplexMetrics(@Body() complexData: any = null): Promise<ComplexMetricsCalculation[]> {
        let url: string = 'http://192.168.2.39:9999/api/complex/5555';
        let options: any = {
            headers: { 'Content-Type': 'application/json' }
        };

        await axios.options(url, options).then((response) => {
            complexData = response.data;
        }).catch((error) => {
            complexData = error;
        });
        // console.log(rangesData);
        return complexData;
    }

    async showRangesOptions(filePath: string): Promise<JSON> {
        let content: JSON = JSON.parse('{"name":"name"}');
        filePath = './src/zvksmetrics/conf/ranges.json';
        try {
            content = JSON.parse(await readFile(filePath, { encoding: 'utf8' }));
        }
        catch {
            console.log('Error read file');
        }

        return content;
    }

    async showComplexMetricsConfig(filePath: string): Promise<JSON> {
        let content: JSON = JSON.parse('{"name":"name"}');
        filePath = './src/zvksmetrics/conf/complex.json';
        try {
            content = JSON.parse(await readFile(filePath, { encoding: 'utf8' }));
        }
        catch {
            console.log('Error read file');
        }

        return content;
    }


};