import { Body, Injectable } from '@nestjs/common';
import axios, { Axios, AxiosResponse } from 'axios';
import { readFile } from 'node:fs/promises';
import { response } from 'express';
import { json } from 'node:stream/consumers';
import math, { create, all, evaluate, number, random, complex, string } from 'mathjs'


@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);


        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, comlexCalc: ComplexMetricsCalculation[], 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 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);
                let status = 3;
                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 = status;
                complexMetric.device = devices[d];
                complexMetric.source = metr.source;
                metrics.push(complexMetric);
            }
        }

        console.log(complexData);

        return complexData;
    }

    async setComplexMetricValue(value: string, formula: string, currMetrics: MetricK2[], prevMetrics: MetricK2[], device: number, obj: any): Promise<number> {
        const val = JSON.parse(JSON.stringify(value));
        let arr = val.arr;
        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++) {
            arr[i] = currMetrics.find(element => element.name == arr[i] && element.device == device)?.value;
        }
        let prevarr = val.prevarr;
        if (prevarr) {
            let prevarr_len: number = prevarr.length;
            for (let i = 0; i < prevarr_len; i++) {
                prevarr[i] = prevMetrics.find(element => element.name == prevarr[i] && element.device == device)?.value;
            }
        }
        
        // console.log(obj.soure);
        let result: number = evaluate(formula, val);
        // console.log(result);
        return result;
    }

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

    async sendMetrics(inputData: K2Metrics): Promise<string> {
        let resp: any;
        let path: string = 'http://192.168.2.34:9050/update';
        let body: any = 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 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;
    }


};