using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using DarkUI.Controls;
using DarkUI.Forms;

internal class ClassEditor
{
    public List<string> Ecus_Definitions_Compatible = new List<string>();
    public List<string> Ecus_Definitions_Compatible_filename = new List<string>();

    //Variables for loaded rom definition
    public List<string> DefinitionsLocationsX = new List<string>();
    public List<string> DefinitionsLocationsY = new List<string>();
    public List<string> DefinitionsLocationsTable = new List<string>();
    public List<string> DefinitionsMathX = new List<string>();
    public List<string> DefinitionsMathY = new List<string>();
    public List<string> DefinitionsMathTable = new List<string>();
    public List<string> DefinitionsMathXInverted = new List<string>();
    public List<string> DefinitionsMathYInverted = new List<string>();
    public List<string> DefinitionsMathTableInverted = new List<string>();
    public List<string> DefinitionsFormatX = new List<string>();
    public List<string> DefinitionsFormatY = new List<string>();
    public List<string> DefinitionsFormatTable = new List<string>();
    public List<bool> DefinitionsIsSingleByteX = new List<bool>();
    public List<bool> DefinitionsIsSingleByteY = new List<bool>();
    public List<bool> DefinitionsIsSingleByteTable = new List<bool>();

    public List<string> DefinitionsName = new List<string>();
    public List<string> DefinitionsUnit1 = new List<string>();
    public List<string> DefinitionsUnit2 = new List<string>();
    public List<string> DefinitionsTableSize = new List<string>();
    public List<float> DefinitionsValueMin = new List<float>();
    public List<float> DefinitionsValueMax = new List<float>();
    public List<double> DefinitionsChangeAmount = new List<double>();
    public List<string> DefinitionsHeaders = new List<string>();
    public List<bool> DefinitionsIsXYInverted = new List<bool>();
    public List<bool> DefinitionsIsTableInverted = new List<bool>();
    public List<bool> DefinitionsIsReadOnly = new List<bool>();
    public List<bool> DefinitionsIsUntested = new List<bool>();
    public List<bool> DefinitionsIsNotDefined = new List<bool>();
    public string DefinitionsChecksumLocation = "";
    public string DefinitionsCurrentLoadedECU = "";

    public long SelectedROMLocation;
    public int SelectedTableSize;
    public int SelectedTableIndexInDefinitions;
    public bool IsTableLoadedCorrectly = false;
    public bool CanReloadTablesValues = false;
    public string string_ECU_Name;
    public byte[] ROM_Bytes;
    public string AllROMDifferences;
    public string AllROMDifferencesRedo;
    public bool ValuesChanged = false;
    public bool IsSingleByteX = false;
    public bool IsSingleByteY = false;
    public bool IsSingleByteTable = false;

    public int[] BufferValuesArray = new int[200];
    public int[] BufferTableSize = new int[2];
    public string BufferMath = "";
    private string LastMathDoneCheck = "";
    public string FileFormat = "";     //-> 1mb-fw, 1mb-full, 

    private Editortable Editortable_0;

    internal ClassEditor(ref Editortable Editortable_1)
    {
        Editortable_0 = Editortable_1;
    }

    public float smethod_1()
    {
        return Editortable.float_0;
    }

    public string ValueIncDec(int RowIndex, int CellIndex, bool Increasing, bool Multiply4x)
    {
        float num = this.smethod_1();
        string format = "0";
        string text = Editortable_0.dataGridView_0.Rows[RowIndex].Cells[CellIndex].Value.ToString();
        if (text.Contains(".") || text.Contains(","))
        {
            string[] SplittedCmd = new string[0];
            if (text.Contains(".")) SplittedCmd = text.Split('.');
            if (text.Contains(",")) SplittedCmd = text.Split(',');
            int FormatLenght = SplittedCmd[1].Length;
            
            if (FormatLenght == 0) format = "0.0";
            if (FormatLenght == 1) format = "0.0";
            if (FormatLenght == 2) format = "0.00";
            if (FormatLenght == 3) format = "0.000";
            if (FormatLenght == 4) format = "0.0000";
        }
        if (Multiply4x)
        {
            num *= 4f;
        }
        if (Increasing)
        {
            return (float.Parse(text) + num).ToString(format);
        }
        return (float.Parse(text) - num).ToString(format);
    }

    public void SetFileFormat(byte[] FilesBytes)
    {
        //SH7055 512Kb, SH7058 1Mb, SH72543 2Mb, SH7059 1.5Mb, MPC5554 2Mb, Bosch MED17.9.3 ECU 4Mb, TC179X 4Mb
        if ((FilesBytes.Length - 1) == 0xF7FFF) FileFormat = "1mb-fw";
        if ((FilesBytes.Length - 1) == 0xFFFFF) FileFormat = "1mb-full";
        if ((FilesBytes.Length - 1) == 0x1EFFFF) FileFormat = "2mb-fw";
        if ((FilesBytes.Length - 1) == 0x1FFFFF) FileFormat = "2mb-full";
        if ((FilesBytes.Length - 1) == 0x26FFFF) FileFormat = "4mb-fw";
        if ((FilesBytes.Length - 1) == 0x27FFFF) FileFormat = "4mb-full";
        //if ((FilesBytes.Length - 1) == 0x3FFFFF) FileFormat = "4mb-full";
    }

    public void IncDecreaseSelection(bool Decreasing, bool HoldShift)
    {
        if (!Decreasing)
        {
            int num3 = 0;
            int num4 = 0;
            int j = 0;
            while (j < Editortable_0.dataGridView_0.Rows.Count)
            {
                if (Editortable_0.dataGridView_0.Rows[j].Cells[num4].Selected)
                {
                    Editortable_0.dataGridView_0.Rows[j].Cells[num4].Value = this.ValueIncDec(j, num4, true, HoldShift);
                }
                if (num4 == Editortable_0.dataGridView_0.Columns.Count - 1)
                {
                    num4 = 0;
                    j++;
                }
                else
                {
                    num4++;
                }
                num3++;
            }
        }
        else
        {
            int num5 = 0;
            int num6 = 0;
            int k = 0;
            while (k < Editortable_0.dataGridView_0.Rows.Count)
            {
                if (Editortable_0.dataGridView_0.Rows[k].Cells[num6].Selected)
                {
                    Editortable_0.dataGridView_0.Rows[k].Cells[num6].Value = this.ValueIncDec(k, num6, false, HoldShift);
                }
                if (num6 == Editortable_0.dataGridView_0.Columns.Count - 1)
                {
                    num6 = 0;
                    k++;
                }
                else
                {
                    num6++;
                }
                num5++;
            }
        }
    }

    public void ShortcutsCommand(KeyEventArgs keyEventArgs_0, int int_232)
    {
        bool bool_ = false;
        if (Control.ModifierKeys == Keys.Shift)
        {
            bool_ = true;
        }
        if (keyEventArgs_0.KeyCode == Keys.Delete || int_232 == 1)
        {
            int num = 0;
            int num2 = 0;
            int i = 0;
            //if (Editortable_0.frmOBD2Scan_0 != null)
            //{
                while (i < Editortable_0.dataGridView_0.Rows.Count)
                {
                    if (Editortable_0.dataGridView_0.Rows[i].Cells[num2].Selected)
                    {
                        Editortable_0.dataGridView_0.Rows[i].Cells[num2].Value = 0;
                    }
                    if (num2 == Editortable_0.dataGridView_0.Columns.Count - 1)
                    {
                        num2 = 0;
                        i++;
                    }
                    else
                    {
                        num2++;
                    }
                    num++;
                }
            //}
        }
        if (keyEventArgs_0.KeyCode == Keys.W || int_232 == 2)
        {
            IncDecreaseSelection(false, bool_);
        }
        if (keyEventArgs_0.KeyCode == Keys.S || int_232 == 3)
        {
            IncDecreaseSelection(true, bool_);
        }
        //Class40 class40_0 = new Class40();
        //this.smethod_4(200).ContinueWith(new Action<Task>(this.<> c.<> 9.method_0));
        //this.smethod_4(200, class40_0).ContinueWith(new Action<Task>(class40_0.method_0));
    }

    private Task smethod_4(int int_232, Class40 class40_0)
    {
        //Class40 class40_0 = new Class40();
        class40_0.taskCompletionSource_0 = new TaskCompletionSource<object>();
        new System.Threading.Timer(new TimerCallback(class40_0.method_0)).Change(int_232, -1);
        return class40_0.taskCompletionSource_0.Task;
    }

    public void GetChanges()
    {
        long num = this.SelectedROMLocation;
        int multiplier = 2;
        if (this.IsSingleByteX || this.IsSingleByteY || this.IsSingleByteTable) multiplier = 1; //###############################


        Editortable_0.GForm_Main_0.method_1("Checking for differences...");

        //Get all Tables values
        double[,] ReadBufferarray = new double[this.BufferTableSize[0], this.BufferTableSize[1]];
        for (int i = 0; i < this.BufferTableSize[0]; i++)   //10columns
        {
            for (int j = 0; j < this.BufferTableSize[1]; j++)   //20rows
            {
                //calculate value inversed to make bytes
                double ThisValue = double.Parse(Editortable_0.dataGridView_0.Rows[j].Cells[i].Value.ToString().Replace(',', '.'), CultureInfo.InvariantCulture);
                ThisValue = DoMath(ThisValue, BufferMath, true, "Table");
                ReadBufferarray[i, j] = (Int16)ThisValue;
            }
        }

        //#############
        double[] ValuesBufferarray = new double[this.SelectedTableSize];
        for (int i = 0; i < this.BufferTableSize[0]; i++)
        {
            for (int j = 0; j < this.BufferTableSize[1]; j++)
            {
                ValuesBufferarray[i * this.BufferTableSize[1] + j] = ReadBufferarray[i, j];
            }
        }
        //#############
        byte[] BytesBufferarray = new byte[this.SelectedTableSize * multiplier];
        for (int i = 0; i < this.SelectedTableSize; i++)
        {
            if (multiplier == 2)
            {
                byte[] ThisBytesToChange = BitConverter.GetBytes((Int16) ValuesBufferarray[i]);
                BytesBufferarray[(i * 2)] = ThisBytesToChange[1];
                BytesBufferarray[(i * 2) + 1] = ThisBytesToChange[0];
            }
            else
            {
                BytesBufferarray[i] = (byte) ValuesBufferarray[i];
            }
        }
        //#############
        byte[] array = new byte[this.SelectedTableSize * multiplier];
        for (int i = 0; i < this.SelectedTableSize * multiplier; i++)
        {
            array[i] = this.ROM_Bytes[num + i];
            //Apply Changes
            this.ROM_Bytes[num + i] = BytesBufferarray[i];
        }

        int num3 = 0;
        string text = null;
        bool DiffDetected = false;
        foreach (int num4 in BytesBufferarray)
        {
            if (num4.ToString() != array[num3].ToString())
            {
                string BufText = "Change at line: " + num3.ToString() + "[" + array[num3].ToString("X2") + "->" + num4.ToString("X2") + "] | At: 0x" + (this.SelectedROMLocation + num3).ToString("X");
                text = text + BufText + Environment.NewLine;
                Editortable_0.GForm_Main_0.method_1(BufText);
                DiffDetected = true;
            }
            num3++;
        }
        if (!DiffDetected) Editortable_0.GForm_Main_0.method_1("No differences detected");
        if (DiffDetected)
        {
            this.AllROMDifferencesRedo = "";
            this.Editortable_0.redoToolStripMenuItem.Enabled = false;
        }
        this.AllROMDifferences = this.AllROMDifferences + text;
        //this.string_3 = this.string_3 + "Address: " + this.SelectedROMLocation.ToString() + Environment.NewLine + text;
        //this.string_3 = this.string_3 + "Table: " + TableSize + Environment.NewLine + "Address: " + this.SelectedROMLocation.ToString() + Environment.NewLine + text;
    }

    public void SaveROMBytes(string string_4)
    {
        //try
        //{
            if (this.ValuesChanged && this.SelectedTableSize != 0 && this.SelectedROMLocation != 0)
            {
                this.GetChanges();
            }
            this.ValuesChanged = false;

            //################################################
            byte[] SavingBytes = this.ROM_Bytes;

            //Remove fake bootloader section if it's a partial firmware .bin file
            if (!this.Editortable_0.IsFullBinary)
            {
                if (FileFormat == "1mb-fw")
                {
                    byte[] BufferBytes = new byte[SavingBytes.Length - 0x8000];
                    for (int i = 0; i < BufferBytes.Length; i++) BufferBytes[i] = SavingBytes[i + 0x8000];
                    SavingBytes = BufferBytes;
                }
                if (FileFormat == "2mb-fw" || FileFormat == "4mb-fw")
                {
                    byte[] BufferBytes = new byte[SavingBytes.Length - 0x10000];
                    for (int i = 0; i < BufferBytes.Length; i++) BufferBytes[i] = SavingBytes[i + 0x10000];
                    SavingBytes = BufferBytes;
                }
            }

            //Fix Checksums
            FixChecksums();

            File.Create(string_4).Dispose();
            File.WriteAllBytes(string_4, SavingBytes);

            //Set LastFileOpened
            string LastOpenFilePath = Application.StartupPath + @"\LastFileOpened.txt";
            File.Create(LastOpenFilePath).Dispose();
            File.WriteAllText(LastOpenFilePath, string_4);
            //################################################
            //Save rom differences changes to logs
            string text = string_4 + "-logs.txt";
            File.Create(text).Dispose();
            File.WriteAllText(text, AllROMDifferences);
            //################################################
            //string text = string_4 + "~temp";
            //string text2 = string_4 + "~temp2";
            /*File.WriteAllBytes(text, this.byte_0);
            File.WriteAllText(text2, this.string_2);
            using (FileStream fileStream = new FileStream(string_4, FileMode.OpenOrCreate))
            {
                FlashGUI.smethod_1(this.string_0 + Environment.NewLine + this.string_1, fileStream);
            }
            using (ZipArchive zipArchive = ZipFile.Open(string_4, ZipArchiveMode.Update))
            {
                zipArchive.CreateEntryFromFile(text, this.string_1);
                zipArchive.CreateEntryFromFile(text2, "CLOG");
            }
            File.Delete(text);
            File.Delete(text2);*/
            DarkMessageBox.Show("Successfully Saved File!.", "Success", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
        /*}
        catch (Exception ex)
        {
            DarkMessageBox.Show("Failed to save file! error: " + Environment.NewLine + ex, "Save file failed", MessageBoxButtons.OK, MessageBoxIcon.Hand);
        }*/
    }

    public void FixChecksums()
    {
        if (!this.Editortable_0.IsFullBinary) this.ROM_Bytes = this.Editortable_0.GForm_Main_0.Class_Checksums_0.VerifyChecksumFWBin(this.ROM_Bytes);
        if (this.Editortable_0.IsFullBinary) this.ROM_Bytes = this.Editortable_0.GForm_Main_0.Class_Checksums_0.VerifyChecksumFullBin(this.ROM_Bytes);

    }

    public void SetTableValues(int[] TableSize, long ROMLocationX, string TopLeftString, string RowHeaderString, string[] HeaderStringList, string ThisMathX, string ThisFormatX, bool IsXYInverted, long ROMLocationTable, string ThisMathTable, string ThisTableFormat, bool IsTableInverted, bool IsReadOnly)
    {
        try
        {
            this.SelectedTableSize = TableSize[0] * TableSize[1];
            BufferValuesArray = new int[SelectedTableSize];
            BufferTableSize = TableSize;

            Editortable_0.dataGridView_0.Rows.Clear();
            Editortable_0.dataGridView_0.Columns.Clear();
            Editortable_0.dataGridView_0.RowTemplate.DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
            Editortable_0.dataGridView_0.TopLeftHeaderCell.Value = TopLeftString;
            Editortable_0.dataGridView_0.AllowUserToAddRows = false;

            //Correct the Table Orientation if Bad
            /*if ((TableSize[1] == 1 && IsInverted) || (TableSize[0] == 1 && !IsInverted))
            {
                int Buf0 = TableSize[1];
                int Buf1 = TableSize[0];
                TableSize[0] = Buf0;
                TableSize[1] = Buf1;
            }*/

            SelectedROMLocation = ROMLocationTable;
            BufferMath = ThisMathTable;

            //Apply Columns(Y)
            if (IsXYInverted)
            {
                for (int i = 0; i < TableSize[1]; i++)
                {
                    if (ROMLocationX != 0)
                    {
                        double num = 0;
                        if (IsSingleByteX) num = (double)this.GetSingleByteValue(ROMLocationX + i);
                        else num = (double)this.GetIntValue(ROMLocationX + i * 2);

                        string HeaderStr = "";
                        if (ThisFormatX != "") HeaderStr = DoMath(num, ThisMathX, false, "X").ToString(ThisFormatX);
                        if (ThisFormatX == "") HeaderStr = DoMath(num, ThisMathX, false, "X").ToString();
                        Editortable_0.dataGridView_0.Columns.Add(HeaderStr, HeaderStr);
                    }
                    else
                    {
                        Editortable_0.dataGridView_0.Columns.Add(RowHeaderString, RowHeaderString);
                    }
                }
            }
            else
            {
                for (int j = 0; j < TableSize[0]; j++) Editortable_0.dataGridView_0.Columns.Add(HeaderStringList[j], HeaderStringList[j]);
            }

            int index = 0;
            while (true)
            {
                if (index >= SelectedTableSize) // More than TableSize (ex: 10x20.. more than 200)
                {
                    int[,] numArray2 = smethod_35<int>(BufferValuesArray, TableSize[0], TableSize[1]);
                    int rowIndex = 0;
                    while (true)
                    {
                        if ((rowIndex >= TableSize[1] && !IsXYInverted) || (rowIndex >= TableSize[0] && IsXYInverted))   //More than Y (make the 3D table)
                        {
                            int num10 = 0;
                            while (true)
                            {
                                if ((num10 >= TableSize[1] && !IsXYInverted) || (num10 >= TableSize[0] && IsXYInverted))   //Another More than Y (set X Header)
                                {
                                    if (!IsXYInverted) SetBackColor(TableSize[0], Editortable.float_1[0], Editortable.float_1[1]);
                                    if (IsXYInverted) SetBackColor(TableSize[1], Editortable.float_1[0], Editortable.float_1[1]);
                                    break;
                                }
                                //Rows(X) Math
                                if (IsXYInverted)
                                {
                                    string ThisHeaderVal = HeaderStringList[num10];
                                    if (ThisHeaderVal == "") ThisHeaderVal = RowHeaderString;
                                    Editortable_0.dataGridView_0.Rows[num10].HeaderCell.Value = ThisHeaderVal;
                                }
                                else
                                {
                                    if (ROMLocationX != 0)
                                    {
                                        double num = 0;
                                        if (IsSingleByteX) num = (double)this.GetSingleByteValue(ROMLocationX + num10);
                                        else num = (double)this.GetIntValue(ROMLocationX + num10 * 2);
                                        if (ThisFormatX != "") Editortable_0.dataGridView_0.Rows[num10].HeaderCell.Value = DoMath(num, ThisMathX, false, "X").ToString(ThisFormatX);
                                        if (ThisFormatX == "") Editortable_0.dataGridView_0.Rows[num10].HeaderCell.Value = DoMath(num, ThisMathX, false, "X").ToString();
                                    }
                                    else
                                    {
                                        Editortable_0.dataGridView_0.Rows[num10].HeaderCell.Value = RowHeaderString;
                                    }
                                }
                                num10++;
                            }
                            break;
                        }

                        //TableMath (Get full 1full row of value at a time)
                        string[] values = new string[0];
                        if (IsXYInverted)
                        {
                            values = new string[TableSize[1]];
                            for (int i = 0; i < TableSize[1]; i++)
                            {
                                if (ThisTableFormat.Contains("X"))
                                {
                                    //Display Values in Hexadecimals
                                    string Mathhh = DoMath((double)numArray2[rowIndex, i], ThisMathTable, false, "Table").ToString();
                                    try
                                    {
                                        if (ThisTableFormat == "X4") values[i] = Int16.Parse(Mathhh).ToString(ThisTableFormat);
                                        else if (ThisTableFormat == "X8") values[i] = Int32.Parse(Mathhh).ToString(ThisTableFormat);
                                        else values[i] = int.Parse(Mathhh).ToString(ThisTableFormat);
                                    }
                                    catch
                                    {
                                        values[i] = Mathhh;
                                    }
                                }
                                else
                                {
                                    //Display Values in double/int
                                    if (ThisTableFormat != "") values[i] = DoMath((double)numArray2[rowIndex, i], ThisMathTable, false, "Table").ToString(ThisTableFormat);
                                    if (ThisTableFormat == "") values[i] = DoMath((double)numArray2[rowIndex, i], ThisMathTable, false, "Table").ToString();
                                }
                            }
                        }
                        else
                        {
                            values = new string[TableSize[0]];
                            for (int i = 0; i < TableSize[0]; i++)
                            {
                                if (ThisTableFormat.Contains("X"))
                                {
                                    //Display Values in Hexadecimals
                                    string Mathhh = DoMath((double)numArray2[i, rowIndex], ThisMathTable, false, "Table").ToString();
                                    try
                                    {
                                        if (ThisTableFormat == "X4") values[i] = Int16.Parse(Mathhh).ToString(ThisTableFormat);
                                        else if (ThisTableFormat == "X8") values[i] = Int32.Parse(Mathhh).ToString(ThisTableFormat);
                                        else values[i] = int.Parse(Mathhh).ToString(ThisTableFormat);
                                    }
                                    catch
                                    {
                                        values[i] = Mathhh;
                                    }
                                }
                                else
                                {
                                    //Display Values in double/int
                                    if (ThisTableFormat != "") values[i] = DoMath((double)numArray2[i, rowIndex], ThisMathTable, false, "Table").ToString(ThisTableFormat);
                                    if (ThisTableFormat == "") values[i] = DoMath((double)numArray2[i, rowIndex], ThisMathTable, false, "Table").ToString();
                                }
                            }
                        }
                        Editortable_0.dataGridView_0.Rows.Insert(rowIndex, values);
                        rowIndex++;
                    }
                    break;
                }

                //Math perfomed just above
                if (IsSingleByteTable) BufferValuesArray[index] = GetSingleByteValue(SelectedROMLocation + index);
                else BufferValuesArray[index] = GetIntValue(SelectedROMLocation + (index * 2));

                index++;
            }

            //##############################################################################################################
            //Invert inner tables values X and Y
            if (IsTableInverted)
            {
                int[,] numArray2 = smethod_35<int>(BufferValuesArray, TableSize[1], TableSize[0]);

                for (int i = 0; i < Editortable_0.dataGridView_0.ColumnCount; i++)
                {
                    for (int i2 = 0; i2 < Editortable_0.dataGridView_0.RowCount; i2++)
                    {
                        string valueinner = "";
                        if (IsXYInverted)
                        {
                            if (ThisTableFormat != "") valueinner = DoMath((double)numArray2[i, i2], ThisMathTable, false, "Table").ToString(ThisTableFormat);
                            if (ThisTableFormat == "") valueinner = DoMath((double)numArray2[i, i2], ThisMathTable, false, "Table").ToString();
                        }
                        else
                        {
                            if (ThisTableFormat != "") valueinner = DoMath((double)numArray2[i2, i], ThisMathTable, false, "Table").ToString(ThisTableFormat);
                            if (ThisTableFormat == "") valueinner = DoMath((double)numArray2[i2, i], ThisMathTable, false, "Table").ToString();
                        }

                        Editortable_0.dataGridView_0.Rows[i2].Cells[i].Value = valueinner;
                    }
                }
            }
            //##############################################################################################################

            Editortable_0.dataGridView_0.ReadOnly = IsReadOnly;
            foreach (object obj in Editortable_0.dataGridView_0.Columns)
            {
                DataGridViewColumn dataGridViewColumn = (DataGridViewColumn)obj;
                dataGridViewColumn.SortMode = DataGridViewColumnSortMode.NotSortable;
                //dataGridViewColumn.Width = 50;
            }
            foreach (object obj2 in ((IEnumerable)Editortable_0.dataGridView_0.Rows))
            {
                DataGridViewRow dataGridViewRow2 = (DataGridViewRow)obj2;
                dataGridViewRow2.Height = 20;
            }
            this.SetBackColor(TableSize[0], Editortable.float_1[0], Editortable.float_1[1]);
            this.IsTableLoadedCorrectly = true;
        }
        catch (Exception ex)
        {
            this.IsTableLoadedCorrectly = false;
            DarkMessageBox.Show("Failed to load table. " + ex.ToString());
        }
    }

    private int GetNearestMathIndex(string ThisMath)
    {
        int IndexOfNearest = -1;
        int IndexOfMathDiv = ThisMath.IndexOf('/');
        int IndexOfMathMul = ThisMath.IndexOf('*');
        int IndexOfMathAdd = ThisMath.IndexOf('+');
        //int IndexOfMathSub = ThisMath.IndexOf('-'); //don't check for sub, this is causing issue with negative number

        if (IndexOfMathDiv == 0) return 0;
        if (IndexOfMathMul == 0) return 0;
        if (IndexOfMathAdd == 0) return 0;

        if (IndexOfMathDiv == -1) IndexOfMathDiv = 99;
        if (IndexOfMathMul == -1) IndexOfMathMul = 99;
        if (IndexOfMathAdd == -1) IndexOfMathAdd = 99;

        if (IndexOfMathDiv > 0 && IndexOfMathDiv < IndexOfMathMul && IndexOfMathDiv < IndexOfMathAdd) IndexOfNearest = IndexOfMathDiv;
        if (IndexOfMathMul > 0 && IndexOfMathMul < IndexOfMathDiv && IndexOfMathMul < IndexOfMathAdd) IndexOfNearest = IndexOfMathMul;
        if (IndexOfMathAdd > 0 && IndexOfMathAdd < IndexOfMathMul && IndexOfMathAdd < IndexOfMathDiv) IndexOfNearest = IndexOfMathAdd;

        if (IndexOfNearest == 99) IndexOfNearest = -1;

        return IndexOfNearest;
    }

    private char GetNextMath(string ThisMath)
    {
        int Thisindex = GetNearestMathIndex(ThisMath);
        return ThisMath.Substring(Thisindex, 1)[0];
    }

    private double GetNextValue(string ThisMath)
    {
        double Value = 0;

        int Nearestindex = GetNearestMathIndex(ThisMath);
        if (Nearestindex == 0) ThisMath = ThisMath.Substring(1);

        if (Nearestindex == -1)
        {
            Value = double.Parse(ThisMath.Replace(',', '.'), CultureInfo.InvariantCulture);
        }
        else
        {
            string ThisVarStr = ThisMath.Substring(0, Nearestindex);
            Value = double.Parse(ThisVarStr.Replace(',', '.'), CultureInfo.InvariantCulture);
        }

        return Value;
    }

    public string InvertMathString(string ThisMath)
    {
        string ReturnStr = "";
        List<double> ValuesList = new List<double>();
        List<char> MathFuncList = new List<char>();
        bool WeHaveVal1 = false;
        while (ThisMath != "")
        {
            if (!WeHaveVal1) ValuesList.Add(GetNextValue(ThisMath));
            MathFuncList.Add(GetNextMath(ThisMath));
            ThisMath = ThisMath.Substring(GetNearestMathIndex(ThisMath) + 1);
            ValuesList.Add(GetNextValue(ThisMath));

            int NearestIndex = GetNearestMathIndex(ThisMath);
            if (NearestIndex != -1) ThisMath = ThisMath.Substring(GetNearestMathIndex(ThisMath));

            WeHaveVal1 = true;

            if (!ThisMath.Contains("/") && !ThisMath.Contains("*") && !ThisMath.Contains("+"))
            {
                ThisMath = ""; //No remaining maths to perform
            }
        }

        //Create inverted math function
        for (int i = ValuesList.Count - 1; i >= 0; i--)
        {
            ReturnStr = ReturnStr + ValuesList[i];
            if (i > 0)
            {
                if (MathFuncList[i - 1] == '*') ReturnStr = ReturnStr + "/";
                if (MathFuncList[i - 1] == '/') ReturnStr = ReturnStr + "*";
                if (MathFuncList[i - 1] == '+') ReturnStr = ReturnStr + "+-";
            }
        }

        return ReturnStr;
    }

    public string SwipeMathFunc(string ThisMath)
    {
        string ReturnStr = "";
        List<char> MathFuncList = new List<char>();
        List<double> ValuesList = new List<double>();
        bool WeHaveVal1 = false;
        while (ThisMath != "")
        {
            if (!WeHaveVal1) ValuesList.Add(GetNextValue(ThisMath));
            MathFuncList.Add(GetNextMath(ThisMath));
            ThisMath = ThisMath.Substring(GetNearestMathIndex(ThisMath) + 1);
            ValuesList.Add(GetNextValue(ThisMath));

            int NearestIndex = GetNearestMathIndex(ThisMath);
            if (NearestIndex != -1) ThisMath = ThisMath.Substring(GetNearestMathIndex(ThisMath));

            WeHaveVal1 = true;

            if (!ThisMath.Contains("/") && !ThisMath.Contains("*") && !ThisMath.Contains("+"))
            {
                ThisMath = ""; //No remaining maths to perform
            }
        }

        //Create swiped math function
        for (int i = 0; i < ValuesList.Count; i++)
        {
            if (i > 0)
            {
                if (i > 1) ReturnStr = ReturnStr + MathFuncList[i - 2].ToString();
                else ReturnStr = ReturnStr + MathFuncList[MathFuncList.Count - 1].ToString();
            }
            ReturnStr = ReturnStr + ValuesList[i];
        }

        return ReturnStr;
    }


    public double DoMath(double ThisValueCheck, string ThisMath, bool Reverse, string Direction)
    {
        //Check if the reversed math function exist, if not we perform the reversed math function manually
        bool ReversFinalForMath = Reverse;
        if (Reverse)
        {
            if (Direction == "X" && DefinitionsMathXInverted[SelectedTableIndexInDefinitions] != "")
            {
                ThisMath = DefinitionsMathXInverted[SelectedTableIndexInDefinitions];
                ReversFinalForMath = false;
            }
            if (Direction == "Y" && DefinitionsMathYInverted[SelectedTableIndexInDefinitions] != "")
            {
                ThisMath = DefinitionsMathYInverted[SelectedTableIndexInDefinitions];
                ReversFinalForMath = false;
            }
            if (Direction == "Table" && DefinitionsMathTableInverted[SelectedTableIndexInDefinitions] != "")
            {
                ThisMath = DefinitionsMathTableInverted[SelectedTableIndexInDefinitions];
                ReversFinalForMath = false;
            }
        }

        //Perform Math
        double ReturnVal = DoMathFinal(ThisValueCheck, ThisMath, ReversFinalForMath);

        //################################################
        //Confirm Math function in reverse
        if (!Reverse)
        {
            bool PerformedNormalReverse = true;

            //Has the reversed math function existing
            if (Direction == "X" && DefinitionsMathXInverted[SelectedTableIndexInDefinitions] != "")
            {
                ThisMath = DefinitionsMathXInverted[SelectedTableIndexInDefinitions];
                PerformedNormalReverse = false;
            }
            if (Direction == "Y" && DefinitionsMathYInverted[SelectedTableIndexInDefinitions] != "")
            {
                ThisMath = DefinitionsMathYInverted[SelectedTableIndexInDefinitions];
                PerformedNormalReverse = false;
            }
            if (Direction == "Table" && DefinitionsMathTableInverted[SelectedTableIndexInDefinitions] != "")
            {
                ThisMath = DefinitionsMathTableInverted[SelectedTableIndexInDefinitions];
                PerformedNormalReverse = false;
            }

            //Has NOT the reversed math function existing
            double ReversedVal = DoMathFinal(ReturnVal, ThisMath, PerformedNormalReverse);
            if (((int) ReversedVal).ToString() != ((int) ThisValueCheck).ToString()
                && ((int)ReversedVal + 1).ToString() != ((int)ThisValueCheck).ToString()
                && ((int)ReversedVal - 1).ToString() != ((int)ThisValueCheck).ToString())
            {
                if (LastMathDoneCheck != ThisMath)
                {
                    Editortable_0.GForm_Main_0.method_1("Problem with inverted math: " + ThisMath + " | Values: " + ((int)ThisValueCheck).ToString() + " != " + ((int)ReversedVal).ToString());
                    LastMathDoneCheck = ThisMath;
                }
                //suggested to set 'ReadOnly' parameters when there is math problem.
                //when there is math problem, it mean the inverted function of your math doesn't return the exact bytes values as within the binary.
                //The problem come from the math inversion in the function bellow 'DoMathFinal'

                //DefinitionsIsReadOnly
            }
        }

        return ReturnVal;
    }

    //public double DoMath(double ThisValue, string ThisMath, bool Reverse)
    public double DoMathFinal(double ThisValue, string ThisMath, bool Reverse)
    {
        double ReturnVal = ThisValue;

        //No Math found, return value with no math calculation
        if (ThisMath == "X" || ThisMath == "") return ReturnVal;

        //Put X at the end in reverse
        bool IsDivXValFirst = false;
        if (Reverse)
        {
            if (ThisMath.Contains("X/")) IsDivXValFirst = true;

            if (ThisMath[ThisMath.Length - 1] != 'X')
            {
                string XandMath = ThisMath.Substring(ThisMath.IndexOf('X'), 2);
                ThisMath = ThisMath.Replace(XandMath, "") + XandMath[1].ToString() + XandMath[0].ToString();
            }
        }

        ThisMath = ThisMath.Replace("X", ThisValue.ToString());

        //########################################################
        //double ValTest1 = GetNextValue(ThisMath);
        char MathTestChar = GetNextMath(ThisMath);
        string ThisMathTest = ThisMath.Substring(GetNearestMathIndex(ThisMath) + 1);
        double ValTest2 = GetNextValue(ThisMathTest);
        if (Reverse && MathTestChar == '*' && ValTest2 == 100)
        {
            IsDivXValFirst = true;
            ThisMath = SwipeMathFunc(ThisMath);
        }
        //########################################################

        if (Reverse) ThisMath = InvertMathString(ThisMath);

        //Console.WriteLine("Math: " + ThisMath + " | Reversed: " + Reverse);

        bool WeHaveVal1 = false;
        double Val1 = 0;
        while (ThisMath != "")
        {
            if (!WeHaveVal1) Val1 = GetNextValue(ThisMath);
            char MathChar = GetNextMath(ThisMath);
            ThisMath = ThisMath.Substring(GetNearestMathIndex(ThisMath) + 1);
            double Val2 = GetNextValue(ThisMath);

            if (MathChar == '*') ReturnVal = Val1 * Val2;
            if (MathChar == '/') ReturnVal = Val1 / Val2;
            if (MathChar == '+') ReturnVal = Val1 + Val2;

            //Console.WriteLine("Doing: " + Val1 + MathChar.ToString() + Val2 + "=" + ReturnVal);

            if (Reverse && MathChar == '*' && !IsDivXValFirst) ReturnVal = Val2 / Val1;

            int NearestIndex = GetNearestMathIndex(ThisMath);
            if (NearestIndex != -1) ThisMath = ThisMath.Substring(GetNearestMathIndex(ThisMath));

            WeHaveVal1 = true;
            Val1 = ReturnVal;

            //Check for remaining maths
            if (!ThisMath.Contains("/") && !ThisMath.Contains("*") && !ThisMath.Contains("+"))
            {
                ThisMath = ""; //No remaining maths to perform
            }
        }
        return ReturnVal;
    }

    public string[] GetAdvancedHeader(int ValuesCount, long ThisLocation, string ThisMath, string HeaderFormat)
    {
        string[] strArray = new string[ValuesCount];
        for (int i = 0; i < ValuesCount; i++)
        {
            int Valuue = 0;
            if (IsSingleByteY) Valuue = GetSingleByteValue(ThisLocation + i);
            else Valuue = GetIntValue(ThisLocation + (i * 2));

            if (HeaderFormat == "") strArray[i] = DoMath((double) Valuue, ThisMath, false, "Y").ToString();
            if (HeaderFormat != "") strArray[i] = DoMath((double) Valuue, ThisMath, false, "Y").ToString(HeaderFormat);
        }
        return strArray;
    }

    public byte[] StringToByteArray(string hex)
    {
        return Enumerable.Range(0, hex.Length)
                            .Where(x => x % 2 == 0)
                            .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                            .ToArray();
    }

    /*public Int16 ToInt16BE(byte[] TwoBytes)
    {
        Int16 k0 = BitConverter.ToInt16(TwoBytes, 0);
        Int16 k1 = BitConverter.ToInt16(BitConverter.GetBytes(k0).Reverse().ToArray(), 0);
        return k1;
    }

    public Int32 ToInt32BE(byte[] FourBytes)
    {
        Int32 k0 = BitConverter.ToInt32(FourBytes, 0);
        Int32 k1 = BitConverter.ToInt32(BitConverter.GetBytes(k0).Reverse().ToArray(), 0);
        return k1;
    }*/

    public long HexStringToInt(string hex)
    {
        string ThisStr = hex.Replace("0x", "");
        if (ThisStr.Length == 1 || ThisStr.Length == 3 || ThisStr.Length == 5 || ThisStr.Length == 7)
        {
            ThisStr = "0" + ThisStr;
        }
        byte[] ThisBytes = StringToByteArray(ThisStr);
        Array.Reverse(ThisBytes);

        //Add Empty Bytes
        if (ThisBytes.Length == 3)
        {
            byte[] buffArray = new byte[4];
            buffArray[3] = 0;
            for (int i = 0; i < ThisBytes.Length; i++) buffArray[i] = ThisBytes[i];
            ThisBytes = buffArray;
        }
        if (ThisBytes.Length == 5)
        {
            byte[] buffArray = new byte[8];
            buffArray[5] = 0;
            buffArray[6] = 0;
            buffArray[7] = 0;
            for (int i = 0; i < ThisBytes.Length; i++) buffArray[i] = ThisBytes[i];
            ThisBytes = buffArray;
        }
        if (ThisBytes.Length == 6)
        {
            byte[] buffArray = new byte[8];
            buffArray[6] = 0;
            buffArray[7] = 0;
            for (int i = 0; i < ThisBytes.Length; i++) buffArray[i] = ThisBytes[i];
            ThisBytes = buffArray;
        }
        if (ThisBytes.Length == 7)
        {
            byte[] buffArray = new byte[8];
            buffArray[7] = 0;
            for (int i = 0; i < ThisBytes.Length; i++) buffArray[i] = ThisBytes[i];
            ThisBytes = buffArray;
        }

        if (ThisBytes.Length == 2) return BitConverter.ToUInt16(ThisBytes, 0);
        if (ThisBytes.Length == 4) return BitConverter.ToUInt32(ThisBytes, 0);
        if (ThisBytes.Length == 8) return BitConverter.ToInt64(ThisBytes, 0);
        return 0;
    }

    public bool LoadROMbytes(string string_4)
    {
        if (File.Exists(string_4))
        {
            try
            {
                this.ROM_Bytes = File.ReadAllBytes(string_4);

                //Console.WriteLine(Editortable_0.IsFullBinary);
                //Console.WriteLine(FileFormat);

                //Create fake bootloader section
                if (!Editortable_0.IsFullBinary)
                {
                    if (FileFormat == "1mb-fw")
                    {
                        byte[] BufferBytes = new byte[0x8000 + this.ROM_Bytes.Length];
                        for (int i = 0; i < 0x8000; i++) BufferBytes[i] = 0xff;
                        for (int i = 0; i < this.ROM_Bytes.Length; i++) BufferBytes[0x8000 + i] = this.ROM_Bytes[i];
                        this.ROM_Bytes = BufferBytes;
                    }
                    if (FileFormat == "2mb-fw" || FileFormat == "4mb-fw")
                    {
                        long ThisSize = (long)0x10000 + (long)this.ROM_Bytes.Length;
                        byte[] BufferBytes = new byte[ThisSize];
                        for (long i = 0; i < 0x10000; i++) BufferBytes[i] = 0xff;
                        for (long i = 0; i < this.ROM_Bytes.Length; i++) BufferBytes[0x10000 + i] = this.ROM_Bytes[i];
                        this.ROM_Bytes = BufferBytes;
                    }
                }

                //Get ECU filename  (33 37 38 30 35 2D  ->  37805- 'in ASCII chars')  (37805-RRB-A140)
                this.string_ECU_Name = "";
                for (int i = 0; i < this.ROM_Bytes.Length; i++)
                {
                    if (this.ROM_Bytes[i] == 0x33 &&
                        this.ROM_Bytes[i + 1] == 0x37 &&
                        this.ROM_Bytes[i + 2] == 0x38 &&
                        this.ROM_Bytes[i + 3] == 0x30 &&
                        (this.ROM_Bytes[i + 4] == 0x35 || this.ROM_Bytes[i + 4] == 0x36) &&
                        this.ROM_Bytes[i + 5] == 0x2D &&
                        this.ROM_Bytes[i + 10] != 0x5A &&
                        this.ROM_Bytes[i + 11] != 0x5A &&
                        this.ROM_Bytes[i + 12] != 0x5A &&
                        this.ROM_Bytes[i + 13] != 0x5A)
                    {
                        for (int i2 = 0; i2 < 14; i2++)
                        {
                            this.string_ECU_Name += (char)this.ROM_Bytes[i + i2];
                        }
                        break;
                    }
                }
                //##################################################################################################
                //Load all differences made in ROM from logs
                string text = string_4 + "-logs.txt";
                if (File.Exists(text))
                {
                    AllROMDifferences = File.ReadAllText(text);
                }
                return true;
                //##################################################################################################
                /*this.string_0 = array[0];     //37805-RRB-A140
                this.string_1 = array[1];     //Unused
                using (FileStream fileStream = new FileStream(string_4, FileMode.Open))
                {
                    using (ZipArchive zipArchive = new ZipArchive(fileStream, ZipArchiveMode.Read))
                    {
                        foreach (ZipArchiveEntry zipArchiveEntry in zipArchive.Entries)
                        {
                            if (zipArchiveEntry.Name == "CALID")
                            {
                                //string[] array = File.ReadAllLines(Application.StartupPath + @"\CALID\" + string_4);
                                string[] array = this.smethod_0(zipArchiveEntry).Split(new string[]
                                {
                                    Environment.NewLine
                                }, StringSplitOptions.None);
                                this.string_0 = array[0];
                                this.string_1 = array[1];
                                foreach (ZipArchiveEntry zipArchiveEntry2 in zipArchive.Entries)
                                {
                                    if (zipArchiveEntry2.Name == "CLOG")
                                    {
                                        this.string_2 = this.smethod_0(zipArchiveEntry2);
                                    }
                                    if (zipArchiveEntry2.Name == array[1])
                                    {
                                        using (Stream stream = zipArchiveEntry2.Open())
                                        {
                                            using (BinaryReader binaryReader = new BinaryReader(stream))
                                            {
                                                this.byte_0 = binaryReader.ReadBytes((int)zipArchiveEntry2.Length);
                                                return true;
                                            }
                                        }
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
                Editortable_0.GForm_Main_0.method_1("Cannot load Error#1");
                return false;*/
                //##################################################################################################
            }
            catch
            {
                return false;
            }
        }
        return false;
    }

    public int GetIntValue(long int_232)
    {
        return (int)((short)((int)this.ROM_Bytes[int_232] << 8 | (int)this.ROM_Bytes[int_232 + 1]));
    }

    public int GetSingleByteValue(long int_232)
    {
        return (int)this.ROM_Bytes[int_232];
    }

    public void SetBackColor(int int_232, float float_0, float float_1)
    {
        for (int i = 0; i < int_232; i++)
        {
            foreach (object obj in ((IEnumerable)Editortable_0.dataGridView_0.Rows))
            {
                DataGridViewRow dataGridViewRow = (DataGridViewRow)obj;
                try
                {
                    float float_2 = float.Parse(dataGridViewRow.Cells[i].Value.ToString());
                    dataGridViewRow.Cells[i].Style.BackColor = this.GetColor(float_2, float_1, float_0);
                }
                catch
                {
                    dataGridViewRow.Cells[i].Style.BackColor = System.Drawing.SystemColors.ControlLight;
                    //dataGridViewRow.Cells[i].Style.BackColor = Color.White;
                }
            }
        }
    }

    public Color GetColor(float float_0, float float_1, float float_2)
    {
        Color result;

        if (float_0 > float_1) return Color.White;  //More than Maximum
        if (float_0 < float_2) return Color.White;  //Less than Minimum

        try
        {
            int num = (int)(1023f * (float_0 - float_1) / (float_2 - float_1));
            if (num < 256)
            {
                result = Color.FromArgb(255, num, 0);
            }
            else if (num < 512)
            {
                num -= 256;
                result = Color.FromArgb(255 - num, 255, 0);
            }
            else if (num < 768)
            {
                num -= 512;
                result = Color.FromArgb(0, 255, num);
            }
            else
            {
                num -= 768;
                result = Color.FromArgb(0, 255 - num, 255);
            }
        }
        catch
        {
            result = Color.White;
        }
        return result;
    }

                                //Buffer        10      x       20
    public T[,] smethod_35<T>(T[] gparam_0, int int_232, int int_233)
    {
        T[,] array = new T[int_232, int_233];
        for (int i = 0; i < int_232; i++)
        {
            for (int j = 0; j < int_233; j++)
            {
                array[i, j] = gparam_0[i * int_233 + j];
            }
        }
        return array;
    }

    public void LoadSupportedECUDefinitions()
    {
        try
        {
            Ecus_Definitions_Compatible = new List<string>();
            Ecus_Definitions_Compatible_filename = new List<string>();

            Editortable_0.CheckDefinitionFolderExist();

            int LoadedDefCount = 0;

            string Folderpath = Application.StartupPath + @"\Definitions";
            if (Directory.Exists(Folderpath))
            {
                string[] AllDefinitionFiles = Directory.GetFiles(Folderpath, "*.txt", SearchOption.AllDirectories);

                Editortable_0.GForm_Main_0.method_1("Loading definitions files...");
                int CurrentIndex = 0;
                foreach (string ThisFilePath in AllDefinitionFiles)
                {
                    CurrentIndex++;
                    int Percent = (int)((CurrentIndex * 100) / AllDefinitionFiles.Length);
                    Editortable_0.GForm_Main_0.method_4(Percent);

                    string[] AllLines = File.ReadAllLines(ThisFilePath);
                    bool GettingEcuList = true;
                    for (int i = 0; i < AllLines.Length; i++)
                    {
                        string Thisline = AllLines[i];
                        if (Thisline.Contains("ROM Parameters") || Thisline.Contains("Checksum ")) GettingEcuList = false; //make sure we are not reading false contents

                        if (Thisline != "")
                        {
                            if (Thisline[0] != '#')
                            {
                                if (GettingEcuList)
                                {
                                    Ecus_Definitions_Compatible.Add(Thisline);
                                    Ecus_Definitions_Compatible_filename.Add(ThisFilePath);
                                    //Editortable_0.GForm_Main_0.method_1("Definitions found for ecu: " + Thisline);
                                    LoadedDefCount++;
                                }
                            }
                        }

                        if (!GettingEcuList) i = AllLines.Length;
                    }
                }

                Editortable_0.GForm_Main_0.ClearLogs();
                Editortable_0.GForm_Main_0.method_1(LoadedDefCount + " definitions loaded!");
            }
            else
            {
                DarkMessageBox.Show("Failed to find definitions folder.");
            }
        }
        catch (Exception ex)
        {
            DarkMessageBox.Show("Failed to load definitions. " + ex.ToString());
        }

        Editortable_0.GForm_Main_0.ResetProgressBar();
    }

    public void LoadThisECUDefinitions(string ThisECU, int ThisIndexfile)
    {
        if (DefinitionsCurrentLoadedECU == ThisECU) return;

        try
        {
            Editortable_0.CheckDefinitionFolderExist();

            string ThisFilename = Ecus_Definitions_Compatible_filename[ThisIndexfile];

            //string Folderpath = Application.StartupPath + @"\Definitions";
            //if (Directory.Exists(Folderpath))
            if (File.Exists(ThisFilename))
            {
                //string[] AllDefinitionFiles = Directory.GetFiles(Folderpath, "*.txt", SearchOption.AllDirectories);

                DefinitionsLocationsX = new List<string>();
                DefinitionsLocationsY = new List<string>();
                DefinitionsLocationsTable = new List<string>();
                DefinitionsName = new List<string>();
                DefinitionsUnit1 = new List<string>();
                DefinitionsUnit2 = new List<string>();
                DefinitionsTableSize = new List<string>();
                DefinitionsMathX = new List<string>();
                DefinitionsMathY = new List<string>();
                DefinitionsMathTable = new List<string>();
                DefinitionsMathXInverted = new List<string>();
                DefinitionsMathYInverted = new List<string>();
                DefinitionsMathTableInverted = new List<string>();
                DefinitionsValueMin = new List<float>();
                DefinitionsValueMax = new List<float>();
                DefinitionsChangeAmount = new List<double>();
                DefinitionsIsSingleByteX = new List<bool>();
                DefinitionsIsSingleByteY = new List<bool>();
                DefinitionsIsSingleByteTable = new List<bool>();
                DefinitionsHeaders = new List<string>();
                DefinitionsFormatX = new List<string>();
                DefinitionsFormatY = new List<string>();
                DefinitionsFormatTable = new List<string>();
                DefinitionsIsXYInverted = new List<bool>();
                DefinitionsIsTableInverted = new List<bool>();
                DefinitionsIsReadOnly = new List<bool>();
                DefinitionsIsUntested = new List<bool>();
                DefinitionsIsNotDefined = new List<bool>();
                DefinitionsChecksumLocation = "";
                DefinitionsCurrentLoadedECU = ThisECU;

                Editortable_0.GForm_Main_0.method_1("Loading ECU definitions for: " + ThisECU);
                bool ECUFound = false;
                bool ChecksumFound = false;
                bool IsFileGenerated = false;
                //foreach (string ThisFilePath in AllDefinitionFiles)
                //{
                    //string[] AllLines = File.ReadAllLines(ThisFilePath);
                    string[] AllLines = File.ReadAllLines(ThisFilename);
                    bool GettingEcuList = true;

                    string CurrentLocationX = "";
                    string CurrentLocationY = "";
                    string CurrentLocationTable = "";
                    string CurrentName = "";
                    string CurrentUnit1 = "";
                    string CurrentUnit2 = "";
                    string CurrentTableSize = "";
                    string CurrentMathX = "";
                    string CurrentMathY = "";
                    string CurrentMathTable = "";
                    string CurrentMathXInverted = "";
                    string CurrentMathYInverted = "";
                    string CurrentMathTableInverted = "";
                    float CurrentValueMin = 0f;
                    float CurrentValueMax = 255f;
                    double CurrentChangeAmount = 1;
                    bool CurrentIsSingleByteX = false;
                    bool CurrentIsSingleByteY = false;
                    bool CurrentIsSingleByteTable = false;
                    string CurrentFormatX = "";
                    string CurrentFormatY = "";
                    string CurrentFormatTable = "";
                    string CurrentHeaders = "";
                    bool CurrentIsXYInverted = false;
                    bool CurrentIsTableInverted = false;
                    bool CurrentIsReadOnly = false;
                    bool CurrentIsUntested = false;
                    bool CurrentIsNotDefined = false;

                    IsFileGenerated = false;

                    for (int i = 0; i < AllLines.Length; i++)
                    {
                        string Thisline = AllLines[i];
                        if (Thisline.Contains("ROM Parameters") || Thisline.Contains("Checksum ")) GettingEcuList = false; //make sure we are not reading false contents

                        if (Thisline.Contains("THIS FILE AS BEEN GENERATED")) IsFileGenerated = true;

                        //Get supported ecu list from file and check if it's match
                        if (Thisline != "")
                        {
                            if (Thisline[0] != '#')
                            {
                                if (GettingEcuList && Thisline == ThisECU) ECUFound = true;
                            }
                        }

                        if (!ChecksumFound && Thisline.Contains("ChecksumAddress:"))
                        {
                            string[] Commands = Thisline.Split(':');
                            DefinitionsChecksumLocation = Commands[1];
                            ChecksumFound = true;
                        }

                        if (!GettingEcuList && !ECUFound) i = AllLines.Length;
                        if (!GettingEcuList && ECUFound)
                        {
                            //Get Definitions parameters
                            if (Thisline[0] != '#' && Thisline != "")
                            {
                                //ROMLocation Name Unit1 Unit2 TableSize  Math  ValueMin  ValueMax ChangeAmount IsWord  Format  Headers
                                if (Thisline.Contains(":"))
                                {
                                    string[] Commands = Thisline.Split(':');
                                    if (Commands[0] == "ROMLocationX") CurrentLocationX = Commands[1];
                                    if (Commands[0] == "ROMLocationY") CurrentLocationY = Commands[1];
                                    if (Commands[0] == "ROMLocationTable") CurrentLocationTable = Commands[1];
                                    if (Commands[0] == "Name") CurrentName = Commands[1];
                                    if (Commands[0] == "Unit1") CurrentUnit1 = Commands[1];
                                    if (Commands[0] == "Unit2") CurrentUnit2 = Commands[1];
                                    if (Commands[0] == "TableSize") CurrentTableSize = Commands[1];
                                    if (Commands[0] == "MathX") CurrentMathX = Commands[1];
                                    if (Commands[0] == "MathY") CurrentMathY = Commands[1];
                                    if (Commands[0] == "MathTable") CurrentMathTable = Commands[1];
                                    if (Commands[0] == "MathXInverted") CurrentMathXInverted = Commands[1];
                                    if (Commands[0] == "MathYInverted") CurrentMathYInverted = Commands[1];
                                    if (Commands[0] == "MathTableInverted") CurrentMathTableInverted = Commands[1];
                                    if (Commands[0] == "ValueMin") CurrentValueMin = (float) double.Parse(Commands[1].Replace(',', '.'), CultureInfo.InvariantCulture);
                                    if (Commands[0] == "ValueMax") CurrentValueMax = (float) double.Parse(Commands[1].Replace(',', '.'), CultureInfo.InvariantCulture);
                                    if (Commands[0] == "ChangeAmount") CurrentChangeAmount = double.Parse(Commands[1].Replace(',', '.'), CultureInfo.InvariantCulture);
                                    if (Commands[0] == "IsSingleByteX") CurrentIsSingleByteX = bool.Parse(Commands[1].ToLower());
                                    if (Commands[0] == "IsSingleByteY") CurrentIsSingleByteY = bool.Parse(Commands[1].ToLower());
                                    if (Commands[0] == "IsSingleByteTable") CurrentIsSingleByteTable = bool.Parse(Commands[1].ToLower());
                                    if (Commands[0] == "FormatX") CurrentFormatX = Commands[1];
                                    if (Commands[0] == "FormatY") CurrentFormatY = Commands[1];
                                    if (Commands[0] == "FormatTable") CurrentFormatTable = Commands[1];
                                    if (Commands[0] == "Headers") CurrentHeaders = Commands[1];
                                    if (Commands[0] == "IsXYInverted") CurrentIsXYInverted = bool.Parse(Commands[1].ToLower());
                                    if (Commands[0] == "IsTableInverted") CurrentIsTableInverted = bool.Parse(Commands[1].ToLower());
                                    if (Commands[0] == "IsReadOnly") CurrentIsReadOnly = bool.Parse(Commands[1].ToLower());
                                    if (Commands[0] == "IsUntested") CurrentIsUntested = bool.Parse(Commands[1].ToLower());
                                    if (Commands[0] == "IsNotDefined") CurrentIsNotDefined = bool.Parse(Commands[1].ToLower());
                                }
                            }

                            //Insert Definitions
                            //if (Thisline.Contains("######") || Thisline == "")
                            if (Thisline.Contains("######"))
                            {
                                if (CurrentName != "")
                                {
                                    CurrentName = CurrentName.Replace("\\x00b0", "°");
                                    CurrentUnit1 = CurrentUnit1.Replace("\\x00b0", "°");
                                    CurrentUnit2 = CurrentUnit2.Replace("\\x00b0", "°");
                                    DefinitionsLocationsX.Add(CurrentLocationX);
                                    DefinitionsLocationsY.Add(CurrentLocationY);
                                    DefinitionsLocationsTable.Add(CurrentLocationTable);
                                    DefinitionsName.Add(CurrentName);
                                    DefinitionsUnit1.Add(CurrentUnit1);
                                    DefinitionsUnit2.Add(CurrentUnit2);
                                    DefinitionsTableSize.Add(CurrentTableSize);
                                    DefinitionsMathX.Add(CurrentMathX);
                                    DefinitionsMathY.Add(CurrentMathY);
                                    DefinitionsMathTable.Add(CurrentMathTable);
                                    DefinitionsMathXInverted.Add(CurrentMathXInverted);
                                    DefinitionsMathYInverted.Add(CurrentMathYInverted);
                                    DefinitionsMathTableInverted.Add(CurrentMathTableInverted);
                                    DefinitionsValueMin.Add(CurrentValueMin);
                                    DefinitionsValueMax.Add(CurrentValueMax);
                                    DefinitionsChangeAmount.Add(CurrentChangeAmount);
                                    DefinitionsIsSingleByteX.Add(CurrentIsSingleByteX);
                                    DefinitionsIsSingleByteY.Add(CurrentIsSingleByteY);
                                    DefinitionsIsSingleByteTable.Add(CurrentIsSingleByteTable);
                                    DefinitionsFormatX.Add(CurrentFormatX);
                                    DefinitionsFormatY.Add(CurrentFormatY);
                                    DefinitionsFormatTable.Add(CurrentFormatTable);
                                    DefinitionsHeaders.Add(CurrentHeaders);
                                    DefinitionsIsXYInverted.Add(CurrentIsXYInverted);
                                    DefinitionsIsTableInverted.Add(CurrentIsTableInverted);
                                    DefinitionsIsReadOnly.Add(CurrentIsReadOnly);
                                    DefinitionsIsUntested.Add(CurrentIsUntested);
                                    DefinitionsIsNotDefined.Add(CurrentIsNotDefined);

                                    //Reset values to default
                                    CurrentLocationX = "";
                                    CurrentLocationY = "";
                                    CurrentLocationTable = "";
                                    CurrentName = "";
                                    CurrentUnit1 = "";
                                    CurrentUnit2 = "";
                                    CurrentTableSize = "";
                                    CurrentMathX = "";
                                    CurrentMathY = "";
                                    CurrentMathTable = "";
                                    CurrentMathXInverted = "";
                                    CurrentMathYInverted = "";
                                    CurrentMathTableInverted = "";
                                    CurrentValueMin = 0f;
                                    CurrentValueMax = 255f;
                                    CurrentChangeAmount = 1f;
                                    CurrentIsSingleByteX = false;
                                    CurrentIsSingleByteY = false;
                                    CurrentIsSingleByteTable = false;
                                    CurrentFormatX = "";
                                    CurrentHeaders = "";
                                    CurrentFormatY = "";
                                    CurrentFormatTable = "";
                                    CurrentIsXYInverted = false;
                                    CurrentIsTableInverted = false;
                                    CurrentIsReadOnly = false;
                                    CurrentIsUntested = false;
                                    CurrentIsNotDefined = false;
                                }
                            }
                        }
                    }

                    if (ECUFound)
                    {
                        Editortable_0.GForm_Main_0.method_1("Definitions loaded!");

                        //HERE
                        if (IsFileGenerated) DarkMessageBox.Show("This Definitions file as been generated to get the ROM Locations.\nThe ROM Locations can possibly be wrong and\nthe tables can display corrupted values!");
                        return;
                    }
                //}

                //if (!ECUFound) Editortable_0.GForm_Main_0.method_1("Definitions NOT loaded!");
                /*}
                else
                {
                    DarkMessageBox.Show("Failed to find definitions folder.");*/
            }
        }
        catch (Exception ex)
        {
            DarkMessageBox.Show("Failed to load definitions. " + ex.ToString());
        }
    }


    [CompilerGenerated]
    private sealed class Class40
    {
        internal Class40()
        {
        }

        internal void method_0(object object_0)
        {
            this.taskCompletionSource_0.SetResult(null);
        }

        public TaskCompletionSource<object> taskCompletionSource_0;
    }

    //########################################################################################################################################
    //########################################################################################################################################
    //########################################################################################################################################
    //########################################################################################################################################

    /*public string smethod_0(ZipArchiveEntry zipArchiveEntry_0)
    {
        string text = "";
        using (Stream stream = zipArchiveEntry_0.Open())
        {
            using (StreamReader streamReader = new StreamReader(stream, Encoding.GetEncoding("iso-8859-1")))
            {
                text += streamReader.ReadToEnd();
            }
        }
        return text;
    }*/

    /*public bool smethod_22(string TableSize)
    {
        int[] arraytableint = new int[0];
        if (TableSize == "1X64") arraytableint = this.int_220;
        if (TableSize == "1X15") arraytableint = this.int_221;
        if (TableSize == "1X8") arraytableint = this.int_222;
        if (TableSize == "1X7") arraytableint = this.int_223;
        if (TableSize == "1X6") arraytableint = this.int_224;
        if (TableSize == "1X5") arraytableint = this.int_225;
        if (TableSize == "1X4") arraytableint = this.int_226;
        if (TableSize == "1X2") arraytableint = this.int_230;
        if (TableSize == "1X1") arraytableint = this.int_231;

        int num = 0;
        int num2 = 0;
        for (int i = 0; i < Editortable_0.dataGridView_0.ColumnCount; i++)
        {
            try
            {
                if (TableSize == "1X64") num2 = (int)float.Parse(Editortable_0.dataGridView_0.Rows[0].Cells[i].Value.ToString(), CultureInfo.InvariantCulture);
                if (TableSize == "1X15") num2 = (int)(32767f / float.Parse(Editortable_0.dataGridView_0.Rows[0].Cells[i].Value.ToString(), CultureInfo.InvariantCulture));
                if (TableSize == "1X8") num2 = (int)(float.Parse(Editortable_0.dataGridView_0.Rows[0].Cells[i].Value.ToString(), CultureInfo.InvariantCulture) / 0.002f);
                if (TableSize == "1X7") num2 = (int)(float.Parse(Editortable_0.dataGridView_0.Rows[0].Cells[i].Value.ToString(), CultureInfo.InvariantCulture) / 0.01f);
                if (TableSize == "1X6") num2 = (int)(float.Parse(Editortable_0.dataGridView_0.Rows[0].Cells[i].Value.ToString(), CultureInfo.InvariantCulture) / 0.005f);
                if (TableSize == "1X5")
                {
                    if (Editortable.genum2_0 == Editortable.GEnum2.INJ_DEADTIME)
                    {
                        num2 = (int)((double)float.Parse(Editortable_0.dataGridView_0.Rows[0].Cells[i].Value.ToString(), CultureInfo.InvariantCulture) / 0.002);
                    }
                    else
                    {
                        num2 = (int)float.Parse(Editortable_0.dataGridView_0.Rows[0].Cells[i].Value.ToString(), CultureInfo.InvariantCulture);
                    }
                }
                if (TableSize == "1X4")
                {
                    if (Editortable.genum2_0 == Editortable.GEnum2.VTEC_PARAMS)
                    {
                        num2 = (int)float.Parse(Editortable_0.dataGridView_0.Rows[i].Cells[0].Value.ToString(), CultureInfo.InvariantCulture);
                    }
                    else
                    {
                        num2 = (int)float.Parse(Editortable_0.dataGridView_0.Rows[0].Cells[i].Value.ToString(), CultureInfo.InvariantCulture);
                    }
                }
                if (TableSize == "1X2")
                {
                    double numBuf = double.Parse(Editortable_0.dataGridView_0.Rows[0].Cells[0].Value.ToString(), CultureInfo.InvariantCulture);
                    if (Editortable_0.dataGridView_0.Columns[0].HeaderText == "MPH") numBuf = Math.Floor(numBuf * 1.609344);
                    num2 = (int)numBuf;
                }
                if (TableSize == "1X1")
                {
                    if (Editortable.genum2_0 == Editortable.GEnum2.MIN_IPW)
                    {
                        double numBuf = double.Parse(Editortable_0.dataGridView_0.Rows[0].Cells[0].Value.ToString(), CultureInfo.InvariantCulture) / 0.002;
                        num2 = (int)numBuf;
                    }
                    else
                    {
                        double numBuf = double.Parse(Editortable_0.dataGridView_0.Rows[0].Cells[0].Value.ToString(), CultureInfo.InvariantCulture);
                        if (Editortable_0.dataGridView_0.Columns[0].HeaderText == "MPH") numBuf = Math.Floor(num * 1.609344);
                        num2 = (int)num;
                    }
                }

                if (TableSize == "1X2" || TableSize == "1X1") num = 0;

                arraytableint[num + 1] = (int)((byte) num2);
                arraytableint[num] = (int)((byte)(num2 >> 8));

                num += 2;
            }
            catch
            {
                return false;
            }
        }

        int num3 = this.int_0;
        int[] array = new int[this.int_1 * 2];
        for (int j = 0; j < this.int_1 * 2; j++)
        {
            array[j] = (int)this.byte_0[num3];
            num3++;
        }

        int num4 = 0;
        foreach (int num5 in arraytableint)
        {
            if (num5.ToString() != array[num4].ToString()) this.bool_2 = true;
            num4++;
        }
        return true;
    }*/

    /*public bool smethod_31()
    {
        if (this.int_1 != 0 && this.int_0 != 0)
        {
            if (this.int_1 == 200)
            {
                return this.smethod_21();
            }
            if (this.int_1 == 64)
            {
                return this.smethod_22("1X64");
            }
            if (this.int_1 == 15)
            {
                return this.smethod_22("1X15");
            }
            if (this.int_1 == 8)
            {
                return this.smethod_22("1X8");
            }
            if (this.int_1 == 7)
            {
                return this.smethod_22("1X7");
            }
            if (this.int_1 == 6)
            {
                return this.smethod_22("1X6");
            }
            if (this.int_1 == 5)
            {
                return this.smethod_22("1X5");
            }
            if (this.int_1 == 4)
            {
                return this.smethod_22("1X4");
            }
            if (this.int_1 == 2)
            {
                return this.smethod_22("1X2");
            }
            if (this.int_1 == 1)
            {
                return this.smethod_22("1X1");
            }
        }
        return false;
    }*/

    /*public void smethod_32()
    {
        Editortable_0.dataGridView_0.ReadOnly = true;
        if (this.bool_0)
        {
            if (this.string_0.Contains("RRB"))
            {
                if (!this.smethod_31())
                {
                    this.bool_2 = false;
                    DarkMessageBox.Show("Table changes fail");
                    return;
                }
            }
            else if (this.string_0.Contains("S2K") && !this.smethod_31())
            {
                this.bool_2 = false;
                DarkMessageBox.Show("Table changes fail");
            }
        }
    }*/
}