using ScottPlot;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json.Nodes;

namespace Elwig.Helpers.Billing {
    public class Graph : ICloneable {

        public BillingData.CurveMode Mode { get; set; }
        public int Id { get; set; }
        private int MinX { get; set; }
        private int MaxX { get; set; }
        public List<Tuple<string, string>> Contracts { get; set; }
        public double[] DataX { get; set; }
        public double[] DataY { get; set; }

        public Graph(int id, BillingData.CurveMode mode, int minX, int maxX) {
            Id = id;
            Mode = mode;
            Contracts = new List<Tuple<string, string>>();
            MinX = minX;
            MaxX = maxX;

            DataX = DataGen.Range(MinX, MaxX + 1);
            DataY = DataGen.Zeros(MaxX - MinX + 1);
        }

        public Graph(int id, BillingData.CurveMode mode, Dictionary<double, decimal> data, int minX, int maxX) {
            Id = id;
            Mode = mode;
            Contracts = new List<Tuple<string, string>>();
            MinX = minX;
            MaxX = maxX;

            DataX = DataGen.Range(MinX, MaxX + 1);
            DataY = DataGen.Zeros(MaxX - MinX + 1);
            ParseGraphData(data);
        }

        public Graph(int id, BillingData.CurveMode mode, int minX, int maxX, List<Tuple<string, string>> contracts, double[] dataX, double[] dataY) {
            Id = id;
            Mode = mode;
            MinX = minX;
            MaxX = maxX;
            Contracts = contracts;
            DataX = dataX;
            DataY = dataY;
        }

        private void ParseGraphData(Dictionary<double, decimal> graphPoints) {
            if (graphPoints.Keys.Count < 1) {
                return;
            }

            var minKey = graphPoints.Keys.Order().First();
            var maxKey = graphPoints.Keys.OrderDescending().First();

            if (!graphPoints.ContainsKey(MinX)) {
                graphPoints.Add(MinX, graphPoints.GetValueOrDefault(minKey));
            }
            if (!graphPoints.ContainsKey(MaxX)) {
                graphPoints.Add(MaxX, graphPoints.GetValueOrDefault(maxKey));
            }

            var keys = graphPoints.Keys.Order().ToArray();

            for (int i = 0; i < keys.Length; i++) {
                decimal point1Value = graphPoints[keys[i]];
                if (i + 1 < keys.Length) {
                    decimal point2Value = graphPoints[keys[i + 1]];
                    if (point1Value == point2Value) {
                        for (int j = (int)(keys[i] - MinX); j < keys[i + 1] - MinX; j++) {
                            DataY[j] = (double)point1Value;
                        }
                    } else {
                        int steps = (int)Math.Abs(keys[i + 1] - keys[i]);
                        decimal step = (point2Value - point1Value) / steps;

                        DataY[(int)(keys[i] - MinX)] = (double)point1Value;
                        DataY[(int)(keys[i + 1] - MinX)] = (double)point2Value;

                        for (int j = (int)(keys[i] - MinX); j < keys[i + 1] - MinX - 1; j++) {
                            DataY[j + 1] = Math.Round(DataY[j] + (double)step, 4); // TODO richtig runden
                        }
                    }
                }
                else {
                    for (int j = (int)(keys[i] - MinX); j < DataX.Length; j++) {
                        DataY[j] = (double)point1Value;
                    }
                }
            }
        }

        public JsonObject ToJson() {
            var graph = new JsonObject {
                ["id"] = Id,
                ["mode"] = Mode.ToString().ToLower(),
            };

            var data = new JsonObject();

            if (DataY[0] != DataY[1]) {
                data.Add(new KeyValuePair<string, JsonNode?>(DataX[0] + Mode.ToString().ToLower(), Math.Round(DataY[0], 4)));
            }
            for (int i = 1; i < DataX.Length - 1; i++) {
                if (Math.Round(DataY[i] - DataY[i - 1], 10) != Math.Round(DataY[i + 1] - DataY[i], 10)) {
                    data.Add(new KeyValuePair<string, JsonNode?>(DataX[i] + Mode.ToString().ToLower(), Math.Round(DataY[i], 4)));
                }
            }
            if (DataY[^1] != DataY[^2]) {
                data.Add(new KeyValuePair<string, JsonNode?>(DataX[^1] + Mode.ToString().ToLower(), Math.Round(DataY[^1], 4)));
            }

            graph["data"] = data;

            return graph;
        }

        public object Clone() {
            return new Graph(Id, Mode, MinX, MaxX, Contracts.ConvertAll(item => new Tuple<string, string>(item.Item1, item.Item2)), (double[])DataX.Clone(), (double[])DataY.Clone());
        }
    }
}