using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using KlassenBIB;
using System.Diagnostics;
using System.IO;
using SanShared;

using System.Collections;
using CSVParser;
using BerichtGen;
using SanShared.Exceptions;
//using Dichtheitsprüfung;
using System.Threading;

namespace SanSystem
{
    /// <summary>
    /// 
    /// </summary>
    public partial class UCInliner : UserControl
    {
        enum TabPages
        {
            VORRAUSSETZUNGEN = 0,
            LINERGRUNDLAGEN
        }
        InlinerSanierung inliner = null;
        string destinationPath = string.Empty;
        UCWerkseitigImprägniert werkseitigImprägniert = null;
        UCLinerGrundlagenBrawo UCLinerGrundlagen = null;
        List<string> filenames = new List<string>();
        /// <summary>
        /// 
        /// </summary>
        /// <param name="san"></param>
        public UCInliner(InlinerSanierung san)
        {
            InitializeComponent();
            inliner = san;
            werkseitigImprägniert = new UCWerkseitigImprägniert(san);
            UCLinerGrundlagen = new UCLinerGrundlagenBrawo(san);

            TabPage tab = new TabPage("Linergrundlagen");
            UCLinerGrundlagen.Dock = DockStyle.Fill;
            tab.Controls.Add(werkseitigImprägniert);
            //tab.Controls.Add(UCLinerGrundlagen);
            tabControl1.TabPages.Add(tab);
        }

        private void tabControl1_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (inliner == null) throw new Exception("Inliner is null");
            TabControl tb = (TabControl)sender;
            if (tb == null) return;
            switch (tb.SelectedIndex)
            {
                case (int)TabPages.LINERGRUNDLAGEN:
                     
                    break;
            }
        }
        
        private void UCInliner_Load(object sender, EventArgs e)
        {
            using(Dongle dongle = new Dongle(60))
            {
                btn_gen_dp.Enabled = dongle.IsLicensed((byte)AktivierteModule.SCHLAUCHLINER) ? true : false;
                dongle.CleanDongle();
            }
            CheckDirectories();
            cb_genehmigung.DataBindings.Clear();
            cb_stvo.DataBindings.Clear();
            cb_wasserhaltung.DataBindings.Clear();
            txt_temp_aussen.DataBindings.Clear();
            txt_temp_kanal.DataBindings.Clear();
            cbb_wetter.DataBindings.Clear();
            txt_besatzung.DataBindings.Clear();
            cb_preliner.DataBindings.Clear();
            txt_einbau_temp.DataBindings.Clear();
            txt_lagerung_temp.DataBindings.Clear();
            txt_einbaudruck.DataBindings.Clear();
            txt_besatzung.DataBindings.Add(new Binding("Text", inliner, "Besatzung"));
            cb_fertig.DataBindings.Add(new Binding("Checked", inliner, "fertig"));
            cb_preliner.DataBindings.Add(new Binding("Checked", inliner, "Preliner"));
            cbb_wetter.DataBindings.Add(new Binding("Text", inliner, "Wetter"));
            txt_lagerung_temp.DataBindings.Add(new Binding("Text", inliner, "LagerungTemperatur"));
            txt_einbau_temp.DataBindings.Add(new Binding("Text", inliner, "EinbauTemperatur"));
            txt_einbaudruck.DataBindings.Add(new Binding("Text", inliner, "InversionsDruck"));
            if (inliner.Datum != null)
            {
                if (inliner.Datum <= DateTime.MinValue || inliner.Datum >= DateTime.MaxValue)
                    inliner.Datum = new DateTime(2018, 01, 01, 12, 0, 0);
            }
            dt_eingebaut.DataBindings.Add(new Binding("Value", inliner, "Datum"));
            cb_genehmigung.DataBindings.Add(new Binding("Checked", inliner, "genehmigungVorhanden"));
            cb_stvo.DataBindings.Add(new Binding("Checked", inliner, "sTVOAbsicherung"));
            cb_wasserhaltung.DataBindings.Add(new Binding("Checked", inliner, "wasserhaltungEingerichtet"));
            txt_temp_aussen.DataBindings.Add(new Binding("Text", inliner, "TempAusen"));
            txt_temp_kanal.DataBindings.Add(new Binding("Text", inliner, "TempKanal"));

            cb_mech.DataBindings.Add(new Binding("Checked", inliner, "VorbereitetMechanisch"));
            cb_roboter.DataBindings.Add(new Binding("Checked", inliner, "VorbereitetRoboter"));
            cb_hd.DataBindings.Add(new Binding("Checked", inliner, "HDReinigung"));
            
        }

        private void cb_fertig_CheckedChanged(object sender, EventArgs e)
        {
            if(cb_fertig.CheckState == CheckState.Checked)
            {
                if(inliner.Datum == null)
                {
                    //inliner.Datum = DateTime.Now;
                    dt_eingebaut.DataBindings.Clear();
                    dt_eingebaut.DataBindings.Add(new Binding("Value", inliner, "Datum"));
                    dt_eingebaut.Enabled = true;

                }
            }
        }

        private void CheckDirectories()
        {
            destinationPath = inliner.CheckVerzeichnisse(Global.Instance.Projektpfad);
        }

        private void btn_get_temp_Click(object sender, EventArgs e)
        {
            ITemperature temperature = TempCAN.TemperaturBuilder.Temperatur(TempCAN.TemperaturSchnittstellen.TINKERFORGE);
            string message = "";
            double temperatur = temperature.GetTemperatur(out message);
            

            if (!message.Equals("")) MessageBox.Show(message);
            else inliner.TempAusen = temperatur;

            txt_temp_aussen.Update();
        }

        /*
        private  void DownloadFromUV()
        {
            Progress<double> progress = new Progress<double>(x =>
            {
                if (x < 0)
                {

                }
                else
                {
                    ftpProgress.Value = Convert.ToInt32(x);
                }
            });
            try
            {
                
                FtpClient client = new FtpClient("192.168.250.2");
                client.Port = 21;
                client.DataConnectionType = FtpDataConnectionType.AutoActive;
                client.Credentials = new System.Net.NetworkCredential("default", "default");
                client.Connect();
                //client.ListingParser = FtpParser.UnixAlt;

                ListFiles(client, "/at0/");
                FtpClient newClient = null;
                client.Dispose();

                //FtpClient newclient = null;
                foreach (string file in filenames)
                {
                    newClient = new FtpClient("192.168.250.2");
                    newClient.Port = 21;
                    newClient.DataConnectionType = FtpDataConnectionType.AutoActive;
                    newClient.Credentials = new System.Net.NetworkCredential("default", "default");

                    if (newClient.IsConnected)
                    {
                        newClient.Connect();
                    }
                    string[] _tdateiname = file.Split('/');
                    string dateiname = _tdateiname[_tdateiname.Length - 1];
                    string ordner = _tdateiname[_tdateiname.Length - 2];

                    newClient.DownloadFile(Path.Combine(destinationPath, ordner, dateiname), file);
                    newClient.DeleteFile(file);

                }
                MessageBox.Show("Daten wurden heruntergeladen und von der Anlage gelöscht", "Fertig", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (TimeoutException ex)
            {
                MessageBox.Show("Die anlage reagiert nicht!\n"+ex.Message);
            }

        }
        */

        private void btn_transfer_ftp_Click(object sender, EventArgs e)
        {
            if (Global.Instance.AnlageType == AcceptedCSVFormats.BLUELIGHT)
            {
                OpenFileDialog openFileDialog = new OpenFileDialog();
                if(Global.CheckNetworkAnlageAvaible())
                    openFileDialog.InitialDirectory = @"\\192.168.2.248";
                if (openFileDialog.ShowDialog() == DialogResult.OK)
                {
                    string source = openFileDialog.FileName;
                    string destFile = string.Format("{0}.csv", inliner.Inspektionsobjekt.Sanierungsnummer);
                    destFile = Path.Combine(destinationPath, destFile);
                    File.Copy(source, destFile, false);
                    File.Delete(source);
                }
            }
            else if(Global.Instance.AnlageType == AcceptedCSVFormats.UVRELINING)
            {
                filenames.Clear();
                if (MessageBox.Show("Bitte stellen Sie sicher, dass der Server antwortet und dass nur die Dateien vorhanden sind!, Bitte beachten Sie, dass das fenster einfrieren kann", "WARNUNG", MessageBoxButtons.OKCancel, MessageBoxIcon.Stop) == DialogResult.OK)
                {
                    //DownloadFromUV();
                }
            }
        }

        /*private void ListFiles(FtpClient client, string directory)
        {
            client.ListingParser = FtpParser.Unix;
            foreach (FtpListItem item in client.GetListing(directory, FtpListOption.ForceNameList))
            {
                if (item.Type == FtpFileSystemObjectType.File)
                {
                    filenames.Add(item.FullName);
                }
                else if (item.Type == FtpFileSystemObjectType.Directory)
                {
                    ListFiles(client, item.FullName);
                }
            }
        }
        */

        private bool AccessCSV()
        {
            string myPath = Path.Combine(destinationPath);
            if (!Directory.Exists(myPath))
                return false;

            IEnumerable<string> files = Directory.EnumerateFiles(myPath, "*.csv", SearchOption.TopDirectoryOnly);

            IReadCSVData csvFile = null;
            List<UVcsvStrukture> struktures = null;
            if (files.Count().Equals(0)) return false;
            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;
                }
                inliner.AnfangAushaertung = struktures.Select(x => x.Zeitstempel).Min();
                inliner.EndeAushaertung = struktures.Select(x => x.Zeitstempel).Max();
                inliner.Rueckholgeschwindigkeit = 0;
            } 
            catch(FileNotFoundException ex)
            {
                MessageBox.Show(string.Format("Datei {0} wurde nicht gefunden", ex.FileName));
            }
            if (struktures == null)
                return false;
            return makeGraphic.GetGraphics(struktures, destinationPath);
        }

        private void Btn_open_file_Click(object sender, EventArgs e)
        {
            Process prozess = new Process();
            prozess.StartInfo.FileName = "explorer";
            try
            {
                prozess.StartInfo.Arguments = destinationPath;
                prozess.Start();
            }
            catch (Exception ex)
            {
                MessageBox.Show("Es ist ein fehler aufgetreten beim öffnen vom Leitungsordner " + ex.Message);
            }
        }

        private void Btn_create_protokol_MouseDown(object sender, MouseEventArgs e)
        {
            
            if(e.Button == MouseButtons.Right)
            {

                frmOffsetSet frmOffsetSet;
                if (inliner.Offset != DateTime.MinValue)
                {
                    frmOffsetSet = new frmOffsetSet(inliner.Offset);
                } else
                {
                    frmOffsetSet = new frmOffsetSet(DateTime.MinValue);
                }
                frmOffsetSet.ShowDialog();
                inliner.Offset = frmOffsetSet.Offset;
                
                
            }
            if (!AccessCSV())
            {
                MessageBox.Show("Warnung, es wurden keine Daten von der Anlage geladen, Grafik konnte nicht erstellt werden");
            }
            Hashtable hashtable = inliner.MakeProtokoll(destinationPath, Database.Datenbank.Instance.loadedProjekt,inliner.Offset);
            DirectoryInfo directory = Directory.GetParent(destinationPath);
            string speicherpfad = directory.FullName;
            speicherpfad = Path.Combine(speicherpfad, "Einbauprotokolle");
            List<BilderObject> bilderObjects = new List<BilderObject>();
            foreach(Sanierung xsan in inliner.Inspektionsobjekt.Sanierung )
            {
                if (xsan is SchachtAnbindung)
                {
                    SchachtAnbindung schacht = (xsan as SchachtAnbindung);
                    
                    foreach(SavedBilder bild in schacht.SavedBilders)
                    {
                        string komment = String.Empty;
                        if (schacht.SchachtNummer != null && !schacht.SchachtNummer.Equals(String.Empty))
                        {
                            komment = string.Format("{0} von Schacht: {1}", bild.Bildname, schacht.SchachtNummer);
                        }
                        bilderObjects.Add(new BilderObject()
                        {
                            Path = bild.Speicherpfad,

                            Kommentar = komment
                        }) ;
                    }
                }
            }
            BerichtGen.FrmOptions options = new BerichtGen.FrmOptions("JUME", "liner_einbauBlueLight.docx", speicherpfad, inliner.Inspektionsobjekt.Objektbezeichnung, hashtable, bilderObjects);
            options.ShowDialog();
        }

        /*
        private void GeneriereDP()
        {
#if DEBUG
            Global.Instance.StatusMessage = "Generiere Daten";
            string dichtheitsprüfungsPfad = Path.Combine(Global.Instance.Projektpfad, "Dichtheitsprüfung");
            if (!Directory.Exists(dichtheitsprüfungsPfad))
                Directory.CreateDirectory(dichtheitsprüfungsPfad);
            DateTime startprüfung = inliner.EndeAushaertung.AddMinutes(20);
            ProtokolWriter protokollWriter = new ProtokolWriter(dichtheitsprüfungsPfad + "/" + inliner.Inspektionsobjekt.Objektbezeichnung + ".txt");
            protokollWriter.haltungsbezeichnung = inliner.Inspektionsobjekt.Objektbezeichnung;
            protokollWriter.Bauvorhaben_Ort = inliner.Inspektionsobjekt.OrtName;
            protokollWriter.Bauvorhaben_Strasse = inliner.Inspektionsobjekt.StrasseName + " " + inliner.Inspektionsobjekt.Hausnummer;
            protokollWriter.Bauvorhaben_Standort = "";
            protokollWriter.vonSchacht = inliner.Inspektionsobjekt.VonPunkt;
            protokollWriter.bisSchacht = inliner.Inspektionsobjekt.BisPunkt;
            protokollWriter.durchmesser = inliner.Inspektionsobjekt.Kanalrohrweite;
            protokollWriter.rohrlaenge = Convert.ToDecimal(inliner.Inspektionsobjekt.Haltungslaenge);
            protokollWriter.AuftraggeberName = inliner.Inspektionsobjekt.OverrideAuftraggeber == null ? Database.Datenbank.Instance.loadedProjekt.Auftraggeber.Name : inliner.Inspektionsobjekt.OverrideAuftraggeber.Name;
            protokollWriter.AuftraggeberOrt = inliner.Inspektionsobjekt.OverrideAuftraggeber == null ? Database.Datenbank.Instance.loadedProjekt.Auftraggeber.Ort : inliner.Inspektionsobjekt.OverrideAuftraggeber.Ort;
            protokollWriter.AuftraggeberStrasse = inliner.Inspektionsobjekt.OverrideAuftraggeber == null ? Database.Datenbank.Instance.loadedProjekt.Auftraggeber.Strasse : inliner.Inspektionsobjekt.OverrideAuftraggeber.Strasse;
            protokollWriter.AuftraggeberTel = "";
            protokollWriter.Projektnummer = Database.Datenbank.Instance.loadedProjekt.Nummer;
            protokollWriter.GenerateMessreiheÜberdruck(startprüfung, 100);
            protokollWriter.Ersetzen();
            try
            {
                protokollWriter.WriteFile();
                Global.Instance.StatusMessage = "Datengenerierung abgeschlossen";
            }
            catch(UnauthorizedAccessException ec)
            {
                Global.Instance.StatusMessage = "Fehler beim generieren von Daten: " + ec.Message + " Wahrscheinlich das Protokollprogramm geöffnet";
            }
#endif
        }
        */

        private void Btn_gen_dp_Click(object sender, EventArgs e)
        {
            if(inliner.EndeAushaertung == DateTime.MinValue)
            {
                if (Debugger.IsAttached)
                {
                    inliner.EndeAushaertung = DateTime.Now;
                }
                else
                {
                    MessageBox.Show("Es konnte das Ende der Aushärtung nicht gefunden werden, breche ab");
                    return;
                }

            }

            //Thread generateDichtheitsprüfung = new Thread(GeneriereDP);
            //generateDichtheitsprüfung.IsBackground = true;
            //generateDichtheitsprüfung.Start();
            
        }

        private void txt_besatzung_Enter(object sender, EventArgs e)
        {
            if (txt_besatzung.Text.Equals(string.Empty) && Global.Instance.AktuelleBesatzung != string.Empty)
            {
                txt_besatzung.Text = Global.Instance.AktuelleBesatzung;
            }
        }

        private void label7_Click(object sender, EventArgs e)
        {

        }

        private void dateTimePicker1_ValueChanged(object sender, EventArgs e)
        {

        }
    }
}