using Adaptation.Shared;
using Adaptation.Shared.Methods;
using log4net;
using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Text.RegularExpressions;
using Tesseract;

namespace Adaptation.FileHandlers.jpeg;

public class ProcessData : IProcessData
{

    private readonly List<object> _Details;

    private readonly ILog _Log;

    public string JobID { get; set; }
    public string MesEntity { get; set; }

    List<object> Shared.Properties.IProcessData.Details => _Details;

    public ProcessData(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection, string tessDataDirectory, int startX, int startY, int endX, int endY, List<(string, Color[])> colorCollections)
    {
        if (logistics is null)
        { }
        JobID = logistics.JobID;
        fileInfoCollection.Clear();
        _Details = new List<object>();
        MesEntity = logistics.MesEntity;
        _Log = LogManager.GetLogger(typeof(ProcessData));
        Parse(fileRead, fileInfoCollection, tessDataDirectory, startX, startY, endX, endY, colorCollections);
    }

    private static string Get(string value, bool useSplitForMID)
    {
        string result = value;
        if (useSplitForMID)
        {
            if (result.IndexOf(".") > -1)
                result = result.Split('.')[0].Trim();
            if (result.IndexOf("_") > -1)
                result = result.Split('_')[0].Trim();
            if (result.IndexOf("-") > -1)
                result = result.Split('-')[0].Trim();
        }
        result = string.Concat(result.Substring(0, 1).ToUpper(), result.Substring(1).ToLower());
        return result;
    }

    string IProcessData.GetCurrentReactor(IFileRead fileRead, Logistics logistics, Dictionary<string, string> reactors)
    {
        string result = string.Empty;
        string filePrefixAsMID;
        foreach (KeyValuePair<string, string> keyValuePair in reactors)
        {
            foreach (string filePrefix in keyValuePair.Value.Split('|'))
            {
                filePrefixAsMID = Get(filePrefix, useSplitForMID: true);
                if (logistics.MID.StartsWith(filePrefix) || logistics.MID.StartsWith(filePrefixAsMID))
                {
                    result = keyValuePair.Key;
                    break;
                }
            }
        }
        if (string.IsNullOrEmpty(result) && reactors.Count == 1)
            result = reactors.ElementAt(0).Key;
        return result;
    }

    Tuple<string, Test[], JsonElement[], List<FileInfo>> IProcessData.GetResults(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection)
    {
        Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
        List<Test> tests = new();
        foreach (object item in _Details)
            tests.Add(Test.CDE);
        List<IDescription> descriptions = fileRead.GetDescriptions(fileRead, tests, this);
        if (tests.Count != descriptions.Count)
            throw new Exception();
        for (int i = 0; i < tests.Count; i++)
        {
            if (descriptions[i] is not Description description)
                throw new Exception();
            if (description.Test != (int)tests[i])
                throw new Exception();
        }
        List<Description> fileReadDescriptions = (from l in descriptions select (Description)l).ToList();
        string json = JsonSerializer.Serialize(fileReadDescriptions, fileReadDescriptions.GetType());
        JsonElement[] jsonElements = JsonSerializer.Deserialize<JsonElement[]>(json);
        results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(logistics.Logistics1[0], tests.ToArray(), jsonElements, fileInfoCollection);
        return results;
    }

#nullable enable
#pragma warning disable CA1416

    private static Color[] Get(string reportFullPath, int startX, int startY, int endX, int endY)
    {
        Color color;
        List<Color> colors = new();
        using Bitmap? bitmap = Image.FromFile(reportFullPath) as Bitmap;
        if (bitmap is null)
            throw new Exception($"Couldn't load image from <{reportFullPath}>");
        for (int x = startX; x < endX; x++)
        {
            for (int y = startY; y < endY; y++)
            {
                color = bitmap.GetPixel(x, y);
                colors.Add(color);
            }
        }
        return colors.ToArray();
    }

    private static System.Drawing.Imaging.ImageFormat Get(string extension)
    {
        System.Drawing.Imaging.ImageFormat imageFormat = extension switch
        {
            ".bmp" => System.Drawing.Imaging.ImageFormat.Bmp,
            ".gif" => System.Drawing.Imaging.ImageFormat.Gif,
            ".jpeg" => System.Drawing.Imaging.ImageFormat.Jpeg,
            ".jpg" => System.Drawing.Imaging.ImageFormat.Jpeg,
            ".png" => System.Drawing.Imaging.ImageFormat.Png,
            ".tiff" => System.Drawing.Imaging.ImageFormat.Tiff,
            _ => throw new Exception("Extension not mapped"),
        };
        return imageFormat;
    }

    private static (Color[], int, int, MemoryStream) Get(string reportFullPath, string extension, int startX, int startY, int endX, int endY)
    {
        Color color;
        List<Color> colors = new();
        MemoryStream memoryStream = new();
        Bitmap selectedBitmap = new(endX - startX, endY - startY);
        System.Drawing.Imaging.ImageFormat imageFormat = Get(extension);
        using Bitmap? bitmap = Image.FromFile(reportFullPath) as Bitmap;
        if (bitmap is null)
            throw new Exception($"Couldn't load image from <{reportFullPath}>");
        for (int x = startX; x < endX; x++)
        {
            for (int y = startY; y < endY; y++)
            {
                color = bitmap.GetPixel(x, y);
                colors.Add(color);
                selectedBitmap.SetPixel(x - startX, y - startY, color);
            }
        }
        selectedBitmap.Save(memoryStream, imageFormat);
        return new(colors.ToArray(), endX - startX, endY - startY, memoryStream);
    }

    private static string Get(string saveFileName, string extension, string extra)
    {
        string result;
        string? directoryName = Path.GetDirectoryName(saveFileName);
        if (string.IsNullOrEmpty(directoryName))
            throw new Exception("Couldn't get directoryName!");
        string? fileNameWithoutExtension = Path.GetFileNameWithoutExtension(saveFileName);
        if (string.IsNullOrEmpty(fileNameWithoutExtension))
            throw new Exception("Couldn't get fileNameWithoutExtension!");
        result = Path.Combine(directoryName, $"{fileNameWithoutExtension} - {extra}{extension}");
        return result;
    }

    private static void SaveToFile(string extension, string saveFileName, MemoryStream memoryStream)
    {
        System.Drawing.Imaging.ImageFormat imageFormat = extension switch
        {
            ".bmp" => System.Drawing.Imaging.ImageFormat.Bmp,
            ".gif" => System.Drawing.Imaging.ImageFormat.Gif,
            ".jpeg" => System.Drawing.Imaging.ImageFormat.Jpeg,
            ".jpg" => System.Drawing.Imaging.ImageFormat.Jpeg,
            ".png" => System.Drawing.Imaging.ImageFormat.Png,
            ".tiff" => System.Drawing.Imaging.ImageFormat.Tiff,
            _ => throw new Exception("Extension not mapped"),
        };
        using Bitmap bitmap = new(memoryStream);
        bitmap.Save(saveFileName, imageFormat);
    }

    private static byte[] Get(bool development, string extension, string saveFileName, Color[] sourceColors, int width, int height, int thresHold, bool saveToFile)
    {
        int i = 0;
        Color color;
        MemoryStream memoryStream = new();
        Bitmap selectedBitmap = new(width, height);
        System.Drawing.Imaging.ImageFormat imageFormat = Get(extension);
        string newSaveFileName = Get(saveFileName, extension, thresHold.ToString("000"));
        for (int x = 0; x < width; x++)
        {
            for (int y = 0; y < height; y++)
            {
                color = sourceColors[i];
                if (color.R > thresHold || color.G > thresHold || color.B > thresHold)
                    selectedBitmap.SetPixel(x, y, Color.Black);
                i += 1;
            }
        }
        selectedBitmap.Save(memoryStream, imageFormat);
        if (development && saveToFile)
            SaveToFile(extension, newSaveFileName, memoryStream);
        byte[] bytes = memoryStream.GetBuffer();
        return bytes;
    }

#pragma warning restore CA1416

    private static void SaveText(int red, int green, string text, string textFileName, List<(string File, int TotalDelta)> totalDeltaCollection, int readAt, string reading, int score)
    {
        string format = "00000";
        List<string> lines = new() { red.ToString(format), green.ToString(format), text };
        foreach ((string file, int totalDelta) in totalDeltaCollection)
        {
            lines.Add(file);
            lines.Add(totalDelta.ToString(format));
        }
        lines.Add(readAt.ToString(format));
        lines.Add(reading);
        lines.Add(score.ToString(format));
        File.WriteAllLines(textFileName, lines);
    }

    internal static List<(string, Color[])> GetColorCollections(int startX, int startY, int endX, int endY, string masterImageDirectory)
    {
        List<(string, Color[])> results = new();
        string[] files = Directory.GetFiles(masterImageDirectory, "*.jpeg", SearchOption.TopDirectoryOnly);
        foreach (string file in files)
            results.Add(new(file, Get(file, startX, startY, endX, endY)));
        return results;
    }

    private void Parse(IFileRead fileRead, List<FileInfo> fileInfoCollection, string tessDataDirectory, int startX, int startY, int endX, int endY, List<(string, Color[])> colorCollections)
    {
        Pix pix;
        int delta;
        Page page;
        int readAt;
        Color color;
        int red = 0;
        string text;
        byte[] bytes;
        int green = 0;
        int totalDelta;
        string textFileName;
        string closestMatchFile;
        const int thresHold = 70;
        string closestMatchFileName;
        List<string> readings = new();
        const int upperThresHold = 153;
        Regex regex = new(@"[^a-zA-Z]");
        const string extension = ".tiff";
        string[] closestMatchFileNameSplit;
        char[] closestMatchFileNameDistinct;
        List<(string File, int TotalDelta)> totalDeltaCollection = new();
        string saveFileName = Path.ChangeExtension(fileRead.ReportFullPath, extension);
        (Color[] sourceColors, int width, int height, MemoryStream memoryStream) = Get(fileRead.ReportFullPath, extension, startX, startY, endX, endY);
        foreach ((string file, Color[] colors) in colorCollections)
        {
            totalDelta = 0;
            if (colors.Length != sourceColors.Length)
                continue;
            for (int i = 0; i < sourceColors.Length; i++)
            {
                color = sourceColors[i];
                if (color.R > thresHold)
                    red += 1;
                if (color.G > thresHold)
                    green += 1;
                delta = color.R - colors[i].R;
                if (delta > 0)
                    totalDelta += delta;
                else
                    totalDelta += delta * -1;
                delta = color.G - colors[i].G;
                if (delta > 0)
                    totalDelta += delta;
                else
                    totalDelta += delta * -1;
            }
            totalDeltaCollection.Add(new(file, totalDelta));
        }
        totalDeltaCollection = (from l in totalDeltaCollection orderby l.TotalDelta select l).ToList();
        bytes = memoryStream.GetBuffer();
        closestMatchFile = totalDeltaCollection[0].File;
        closestMatchFileNameSplit = Path.GetFileNameWithoutExtension(closestMatchFile).Split('-');
        closestMatchFileName = closestMatchFileNameSplit.Last().TrimStart();
        closestMatchFileNameDistinct = closestMatchFileName.Distinct().ToArray();
        using TesseractEngine tesseractEngine = new(tessDataDirectory, "eng", EngineMode.Default);
        pix = Pix.LoadTiffFromMemory(bytes);
        page = tesseractEngine.Process(pix);
        text = page.GetText().Trim();
        pix.Dispose();
        page.Dispose();
        if (!fileRead.IsEAFHosted)
        {
            fileInfoCollection.Add(new FileInfo(saveFileName));
            SaveToFile(extension, saveFileName, memoryStream);
        }
        if (!string.IsNullOrEmpty(text))
        {
            text = regex.Replace(text, string.Empty);
            readings.Add(text);
        }
        if (text == closestMatchFileName)
        {
            readAt = thresHold;
            _Log.Info(text);
            textFileName = Get(saveFileName, ".txt", $"{thresHold:000} - {text}");
            if (!fileRead.IsEAFHosted)
            {
                fileInfoCollection.Add(new FileInfo(textFileName));
                SaveText(red, green, text, textFileName, totalDeltaCollection, readAt, text, int.MaxValue);
            }
        }
        else
        {
            readAt = -1;
            memoryStream.Dispose();
            for (int i = thresHold; i < upperThresHold; i += 10)
            {
                bytes = Get(!fileRead.IsEAFHosted, extension, saveFileName, sourceColors, width, height, i, i == thresHold);
                pix = Pix.LoadTiffFromMemory(bytes);
                page = tesseractEngine.Process(pix);
                text = page.GetText().Trim();
                pix.Dispose();
                page.Dispose();
                if (!string.IsNullOrEmpty(text))
                {
                    text = regex.Replace(text, string.Empty);
                    readings.Add(text);
                }
                if (text == closestMatchFileName)
                {
                    readAt = i;
                    _Log.Info(text);
                    textFileName = Get(saveFileName, ".txt", $"{i:000} - {text}");
                    if (!fileRead.IsEAFHosted)
                    {
                        fileInfoCollection.Add(new FileInfo(textFileName));
                        SaveText(red, green, text, textFileName, totalDeltaCollection, readAt, text, int.MaxValue);
                    }
                    break;
                }
            }
        }
        if (readAt < thresHold)
        {
            int score;
            char[] readingDistinct;
            text = closestMatchFileName;
            List<(string Reading, int Score)> readingEvaluations = new();
            foreach (string reading in readings)
            {
                score = 0;
                readingDistinct = reading.Distinct().ToArray();
                for (int i = 0; i < closestMatchFileNameDistinct.Length; i++)
                {
                    if (!readingDistinct.Contains(closestMatchFileNameDistinct[i]))
                        continue;
                    score += 1;
                }
                readingEvaluations.Add(new(reading, score));
            }
            readingEvaluations = (from l in readingEvaluations orderby l.Score descending select l).ToList();
            textFileName = Get(saveFileName, ".txt", $"{readAt:000} - {readingEvaluations[0].Reading} - {text}");
            if (!fileRead.IsEAFHosted)
            {
                fileInfoCollection.Add(new FileInfo(textFileName));
                SaveText(red, green, text, textFileName, totalDeltaCollection, readAt, readingEvaluations[0].Reading, readingEvaluations[0].Score);
            }
        }
        _Details.Add(text);
    }

}