using BerichtGen;
using CSVParser;
using SanShared;
using SanShared.Exceptions;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace KlassenBIB
{
    /// <summary>
    /// Inliner class
    /// 
    /// </summary>
    public sealed class InlinerSanierung : AbstractSanieren, IMakeProtokol
    {
        double kalibrierUnterdruck = -0.5;
        double kalibierWalzenAbstand = 0.9;
        double harzKalibrierTemperatur;
        DateTime datumKalibrierung;
        string harzChargenummer;
        string linerChargenummer;
        string harzTyp;
        string linerTyp;
        double harzbedarf = 1.8;
        uint rueckholgeschwindigkeit;
        bool geschlosseneEnde = false; // Todo Rausschmeißen
        bool preliner = false;
        int lagerungTemperatur;
        int temperaturEinbau;
        double inversionsDruck;
        DateTime anfangAushaertung;
        DateTime endeAushaertung;
        string ort;
        string bediener;
        DateTime anfangKalibrierung;
        DateTime endeKalibirierung;
        DateTime tvInspektion;
        AbstractImprägnier imprägnierungsbericht;

        Dictionary<int, TimeSpan> lagerungZeiten = new Dictionary<int, TimeSpan>();


        public double GetGesamtHarzbedarf(double haltungslaenge)
        {
            return haltungslaenge * harzbedarf;
        }
       
        public override string CheckVerzeichnisse(string projektpfad)
        {
            string path = Path.Combine(projektpfad, PfadZurSan);
            if (!Directory.Exists(path)) Directory.CreateDirectory(path);

            //string mypath = Path.Combine(path, Verzeichnispfad);
            //if (!Directory.Exists(mypath)) Directory.CreateDirectory(mypath);

            return path;
        }

        public Hashtable MakeProtokoll(string destinationPath, IProjekt projekt, DateTime offset)
        {
            IEnumerable<string> files = Directory.EnumerateFiles(destinationPath, "*.csv", SearchOption.AllDirectories);
            IAuftraggeber auftraggeber = null;

            if (Inspektionsobjekt.OverrideAuftraggeber == null)
                auftraggeber = projekt.Auftraggeber;
            else
                auftraggeber = Inspektionsobjekt.OverrideAuftraggeber;

            IReadCSVData csvFile = null;
            List<UVcsvStrukture> struktures = null;
            if (files.Count() > 0)
            {
                csvFile = CsvParserFactory.ReadCSVFile(AcceptedCSVFormats.BLUELIGHT, files.Last());
                try
                {
                    try
                    {
                        struktures = csvFile.ReadCSVStrukture();
                    }
                    catch (CSVImportException)
                    {
                        //MessageBox.Show("Es scheint den Falschen Anlagentyp angegeben worden sein.", "CSV Datei konnte nicht gelesen werden", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        //return false;
                    }
                    
                    this.AnfangAushaertung = struktures.Select(x => x.Zeitstempel).Min();
                    this.EndeAushaertung = struktures.Select(x => x.Zeitstempel).Max();
                    if (!(offset == DateTime.MinValue))
                    {
                        TimeSpan duration = EndeAushaertung.Subtract(AnfangAushaertung);
                        AnfangAushaertung = offset;
                        EndeAushaertung = AnfangAushaertung.Add(duration);
                    }
                    this.Rueckholgeschwindigkeit = 0;
                }
                catch (FileNotFoundException)
                {
                    //Trace.WriteLine(ex.Message);
                    //MessageBox.Show(string.Format("Datei {0} wurde nicht gefunden", ex.FileName));
                }
            }
            if (struktures != null)
            {
                makeGraphic.GetGraphics(struktures, destinationPath);
                
            }

            Hashtable grunddaten = new Hashtable()
            {
                {"AG_Vorname","" },
                {"hausnummer","" },
                {"KLP_Nummer","" },
                {"KLP_Datum","" },
                {"AG_Ort","" },
                {"AG_Strasse","" },
                {"AG_Ansprechpartner","" },
                {"BM_Ort","" },
                {"BM_Strasse","" },
                {"BM_Schacht_von","" },
                {"BM_Schacht_bis","" },
                {"BM_Haltungsmat","" },
                {"BM_Haltung_DN","" },
                {"BM_Haltunglaenge","" },
                { "KL_Wetter","" },
                { "Temp_Aussen","" },
                { "KL_Temp_Kanal","" },
                { "KL_Gen","" },
                { "KL_WH","" },
                { "KL_STVO","" },
                { "KL_HD_true","" },
                { "KL_mech_true","" },
                { "KL_rob_true","" },
                { "KL_HD_date","" },
                { "KL_Besatzung", "" },
                {"liner_laenge","" },
                {"Charge_Liner","" },
                {"Charge_Harz","" },
                {"harz_bedarf_m","" },
                {"gesamt_harz","" },
                {"temperatur_harz","" },
                {"datum_kalibrierung","" },
                {"walzen_abstand","" },
                {"vakuum","" },
                {"time_start","" },
                {"time_ende","" },
                {"UVImageTemp","" },
                {"UVImageDruck","" },
                {"UVImageSpeed","" },
                {"liner_type","" },
                {"rueckhol_speed","" },
                {"harz_type","" },
                {"preliner_verwendet","" },
                {"geschlossene_ende","" },
                {"schlauch_dn","" },
                {"TV_Kontrolle","" },
                {"Einbau_Temperatur","" },
                {"Inversion_Druck","" },
                {"Lagerung_Text","" },
                {"Lagerung_Temp","" },
                {"Projekt_NR","" }
            };

            double LaengeGesamt = this.Inspektionsobjekt.Haltungslaenge + this.Inspektionsobjekt.Schachtlaenge;

            string KLP_Nummer = Inspektionsobjekt.Sanierungsnummer;
            if (projekt.SanierungsIDPrefix != string.Empty)
                KLP_Nummer = string.Format("{0}{1}", KLP_Nummer, projekt.SanierungsIDPrefix);
            if (projekt.SanierungsIDSuffix != string.Empty)
                KLP_Nummer = string.Format("{0}{1}", projekt.SanierungsIDSuffix,KLP_Nummer);

            if (auftraggeber != null)
            {
                grunddaten["AG_Vorname"] = auftraggeber.Name;
                grunddaten["AG_Ort"] = auftraggeber.Ort;
                grunddaten["AG_Strasse"] = auftraggeber.Strasse;
                grunddaten["AG_Ansprechpartner"] = auftraggeber.Ansprechpartner;
            }
            grunddaten["hausnummer"] = Inspektionsobjekt.Hausnummer;

            grunddaten["KLP_Nummer"] = KLP_Nummer;
            grunddaten["KLP_Datum"] = this.Datum.ToShortDateString();
            grunddaten["BM_Ort"] = Inspektionsobjekt.OrtName;
            grunddaten["BM_Strasse"] = Inspektionsobjekt.StrasseName;
            grunddaten["BM_Schacht_von"] = Inspektionsobjekt.VonPunkt;
            grunddaten["BM_Schacht_bis"] = Inspektionsobjekt.BisPunkt ;
            grunddaten["BM_Haltungsmat"] = Inspektionsobjekt.RohrMaterial;
            grunddaten["BM_Haltung_DN"] = Inspektionsobjekt.Kanalrohrweite;
            grunddaten["BM_Haltunglaenge"] = Inspektionsobjekt.Haltungslaenge;
            grunddaten["KL_Wetter"] = this.Wetter;
            grunddaten["Temp_Aussen"] = this.TempAusen;
            grunddaten["KL_Temp_Kanal"] = this.TempKanal;
            grunddaten["KL_Gen"] = this.GenehmigungVorhanden ? "ja" : "nein";
            grunddaten["KL_WH"] = this.WasserhaltungEingerichtet ? "ja" : "nein";
            grunddaten["KL_STVO"] = this.STVOAbsicherung ? "ja" : "nein";
            grunddaten["KL_HD_true"] = this.HDReinigung ? "X" : " ";
            grunddaten["KL_mech_true"] = this.VorbereitetMechanisch ? "X": " ";
            grunddaten["KL_rob_true"] = this.VorbereitetRoboter ? "X": " ";
            grunddaten["KL_HD_date"] = this.Datum.ToShortDateString();
            grunddaten["KL_Besatzung"] = this.Besatzung;
            grunddaten["liner_laenge"] = Inspektionsobjekt.Haltungslaenge;
            grunddaten["Charge_Liner"] = this.imprägnierungsbericht == null ? this.LinerChargenummer : this.imprägnierungsbericht.Schlauchnummer;
            grunddaten["Charge_Harz"] = this.imprägnierungsbericht == null ? this.HarzChargenummer : (this.imprägnierungsbericht as WerkseitigImprägniert).Imprägniernummer;
            grunddaten["harz_bedarf_m"] = this.imprägnierungsbericht == null ? harzbedarf : this.imprägnierungsbericht.Harzmenge;
            grunddaten["gesamt_harz"] = Inspektionsobjekt.Haltungslaenge * harzbedarf;
            grunddaten["temperatur_harz"] = this.imprägnierungsbericht == null ? this.HarzKalibrierTemperatur : this.imprägnierungsbericht.HarzTemperatur;
            grunddaten["datum_kalibrierung"] = this.imprägnierungsbericht == null ? this.DatumKalibrierung.ToShortDateString() : this.imprägnierungsbericht.ImprägnierDatum;
            grunddaten["walzen_abstand"] = this.imprägnierungsbericht == null ? this.KalibierWalzenAbstand : this.imprägnierungsbericht.Walzenabstand;
            grunddaten["schlauch_dn"] = this.Imprägnierungsbericht != null ? this.imprägnierungsbericht.DN : 0;
            grunddaten["vakuum"] = this.imprägnierungsbericht == null ? this.KalibrierUnterdruck : this.imprägnierungsbericht.Vakuum;
            grunddaten["time_start"] = this.AnfangAushaertung;
            grunddaten["time_ende"] = this.EndeAushaertung;
            grunddaten["preliner_verwendet"] = this.Preliner ? "ja" : "nein";
            grunddaten["geschlossene_ende"] = Inspektionsobjekt.GeschlossenesEnde ? "Geschlossenes" : "Offenes";
            grunddaten["Projekt_NR"] = this.Inspektionsobjekt.Projektnummer;
            grunddaten["UVImageTemp"] = Path.Combine(destinationPath, "linerGraph_temp.jpg");
            grunddaten["UVImageDruck"] = Path.Combine(destinationPath, "linerGraph_druck.jpg");
            grunddaten["UVImageSpeed"] = Path.Combine(destinationPath, "linerGraph_speed.jpg");
            grunddaten["rueckhol_speed"] = rueckholgeschwindigkeit;
            grunddaten["liner_type"] = LinerTyp;
            try
            {
                grunddaten["TV_Kontrolle"] = string.Format("Ja, am {0}", TvInspektion);
            }
            catch(ArgumentOutOfRangeException)
            {
                grunddaten["TV_Kontrolle"] = "UNDEFINIED";
            }
            
            grunddaten["harz_type"] = this.imprägnierungsbericht == null ? HarzTyp : this.imprägnierungsbericht.HarzTyp;
            grunddaten["Lagerung_Temp"] = lagerungTemperatur;
            grunddaten["Einbau_Temperatur"] = temperaturEinbau;
            grunddaten["Inversion_Druck"] = inversionsDruck;
            try
            {
                grunddaten["Lagerung_Text"] = GetLagerungText(DateTime.Parse(imprägnierungsbericht.ImprägnierDatum), this.Datum, lagerungTemperatur);
            }
            catch(NullReferenceException)
            {
                grunddaten["Lagerung_Text"] = "UNDEFINIED (Kein Liner ausgewählt)";
            }
            return grunddaten;
        }
        
        public InlinerSanierung()
        {
            //datumKalibrierung = new DateTime();
            lagerungZeiten.Add(10, TimeSpan.FromDays(90));
            lagerungZeiten.Add(20, TimeSpan.FromDays(30));
            lagerungZeiten.Add(25, TimeSpan.FromDays(7));
            lagerungZeiten.Add(31, TimeSpan.FromDays(3));
            Verzeichnispfad = "UVAnlage";
            if (datumKalibrierung <= DateTime.MinValue || datumKalibrierung >= DateTime.MaxValue) datumKalibrierung = DateTime.Now;
        }

        private TimeSpan GetMaxLagerung(int lagerungTemp)
        {
            Dictionary<int, TimeSpan>.KeyCollection x = lagerungZeiten.Keys;

            int laufer = 0;
            if (lagerungTemp > 31) lagerungTemp = 31;

            foreach(int temp in x)
            {
                if(lagerungTemp <= temp)
                {
                    laufer = temp;
                    break;
                }
            }
            
            return lagerungZeiten[laufer];
        }

        private string GetLagerungText(DateTime Kalibrierdatum, DateTime Einbaudatum, int lagerungTemperatur)
        {
            TimeSpan lagerungszeit = GetMaxLagerung(lagerungTemperatur);

            if(Einbaudatum.Subtract(Kalibrierdatum) <= lagerungszeit)
            {
                return "Die Lagerungsdauer wurde somit nicht überschritten";
            }

            return "Die Lagerungsdauer wurde somit überschritten";
        }
        
        public double KalibrierUnterdruck { get => kalibrierUnterdruck; set => kalibrierUnterdruck = value; }
        
        public double KalibierWalzenAbstand { get => kalibierWalzenAbstand; set => kalibierWalzenAbstand = value; }
        
        public double HarzKalibrierTemperatur { get => harzKalibrierTemperatur; set => harzKalibrierTemperatur = value; }
        
        public DateTime DatumKalibrierung
        {
            get
            {
                return datumKalibrierung;
            }
            set
            {
                datumKalibrierung = value;
            }
        }
        
        public string HarzChargenummer { get => harzChargenummer; set => harzChargenummer = value; }
        
        public string LinerChargenummer { get => linerChargenummer; set => linerChargenummer = value; }
        
        public double Harzbedarf { get => harzbedarf; set => harzbedarf = value; }
        
        public uint Rueckholgeschwindigkeit { get => rueckholgeschwindigkeit; set => rueckholgeschwindigkeit = value; }
       
        public bool GeschlosseneEnde { get => geschlosseneEnde; set => geschlosseneEnde = value; }
        
        public double HarzBedarf { get => harzbedarf; set => harzbedarf = value; }
        
        public string HarzTyp { get => harzTyp; set => harzTyp = value; }
        
        public string LinerTyp { get => linerTyp; set => linerTyp = value; }
        
        public DateTime AnfangAushaertung { get => anfangAushaertung; set => anfangAushaertung = value; }
        
        public DateTime EndeAushaertung { get => endeAushaertung; set => endeAushaertung = value; }
        
        public string Ort { get => ort; set => ort = value; }
        
        public string Bediener { get => bediener; set => bediener = value; }
        
        public DateTime AnfangKalibrierung { get => anfangKalibrierung; set => anfangKalibrierung = value; }
        
        public DateTime EndeKalibirierung { get => endeKalibirierung; set => endeKalibirierung = value; }
        
        public bool Preliner { get => preliner; set => preliner = value; }
        public int LagerungTemperatur { get => lagerungTemperatur; set => lagerungTemperatur = value; }
        public int EinbauTemperatur { get => temperaturEinbau; set => temperaturEinbau = value; }
        public double InversionsDruck { get => inversionsDruck; set => inversionsDruck = value; }
        public AbstractImprägnier Imprägnierungsbericht { get => imprägnierungsbericht; set => imprägnierungsbericht = value; }
        public DateTime TvInspektion { get => tvInspektion; set => tvInspektion = value; }
    }
}