using BrightIdeasSoftware;
using DatenDB;
using Deckungsbeitrag.AA_Forms;
using Deckungsbeitrag.AA_Klassen;
using Deckungsbeitrag.Properties;
using Deckungsbeitrag.UserControls;
using DocumentFormat.OpenXml.Office2013.Excel;
using Microsoft.VisualBasic;
using Microsoft.VisualBasic.ApplicationServices;
using Npgsql;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Diagnostics;
using System.Diagnostics.Eventing.Reader;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.InteropServices.ComTypes;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Windows.Forms.DataVisualization.Charting;
using System.Xml.Resolvers;
using TrelloIntegration;
using ZXing;

namespace Deckungsbeitrag
{
  public enum ListenArt
  {
    Auftragliste = 0,
    Sonderliste = 1,
    Geschäftliste = 2,
    Suchliste = 3,
    Rampenliste = 4,
    Vorbereitetliste = 5
  }


  public partial class FormExpedit : Form
  {
    #region Properties
    
    private readonly UserSettingsManager _settings = new UserSettingsManager();
    private readonly ToolTip cellTooltip = new ToolTip();
    public Meldungen fehlermeldung = new Meldungen();
    public Image etikett = null;
    public Auftrag auftrag;
    public Auftrag NeuerAuftrag; //NEU FÜR UPDATE
    public Benutzer benutzer;
    public Kunde kunde;
    DateTime? letzterLiefertag = null;
    readonly bool nocont = false;
    private readonly Meldungen meldung = new Meldungen();
    private List<KundeArtikel> artikelListe;
    private List<Auftrag> suchliste;
    int? altecontclean = null;
    private readonly Timer timer1 = new Timer(); // Timer für Nachwäsche
    private readonly Timer timer2 = new Timer(); // Timer für Refresh Auftragliste
    private readonly Screen[] screens;
    private Point itemlocation;
    private const int MAX_FAILURES = 3;
    private readonly OnboardingSchritt onBoardingArt = OnboardingSchritt.Expedit;
    private List<View_Auftrag_Expedit> listAuftragToday;
    private List<View_Auftrag_Expedit> listAuftragGeschaeft;
    private List<View_Auftrag_Expedit> listVorbereitet;
    private List<View_Auftrag_Expedit> listSonderAuftrag;
    private List<View_Auftrag_Expedit> listRampe;
    public TrelloCardClient _trelloClient;
    private bool TrelloKarte = true;
    private bool _toPrint = true;
    public bool ToPrint
    {
      get { return _toPrint; }
      set
      {
        _toPrint = value;
        if (_toPrint)
        {
          buttonEtikettenDrucken.Enabled = true;
          buttonEtikettenDrucken.BackColor = Color.FromArgb(0, 192, 0);
        }
        else
        {
          buttonEtikettenDrucken.Enabled = false;
          buttonEtikettenDrucken.BackColor = Color.Gray;
        }
      }
    }

    #endregion
    public FormExpedit(Benutzer benutzer)
    {
      InitializeComponent();

      this.Text += " Version: " + Assembly.GetExecutingAssembly().GetName().Version.ToString();
      this.benutzer = benutzer;
      this.Text += " Benutzer: " + benutzer.Vorname + " " + benutzer.Nachname;
      this.StartPosition = FormStartPosition.CenterScreen;
      this.tabControlAuftragList.Visible = true;
    }
    public FormExpedit(Benutzer benutzer, Screen[] screens) : this(benutzer)
    {
      this.screens = screens;
      foreach (Screen screen in screens)
      {
        if (screen.Primary)
        {
          if (screen.WorkingArea.Width < 1500) { this.objectListViewAuftrag.Font = new Font(this.objectListViewAuftrag.Font.FontFamily, 10); }
        }
      }
    }

    #region Form-Funktionen
    private void FormExpedit_Load(object sender, EventArgs e)
    {
      this.UseWaitCursor = true;
      this.SuspendLayout();
      _settings.Load();
      

      if (TrelloConfig.HasCredentials())
      {
        var apiKey = TrelloConfig.GetApiKey();
        var token = TrelloConfig.GetToken();
        _trelloClient = new TrelloCardClient(apiKey, token);
      }

      UCFeedback fb = new UCFeedback(this.benutzer);
      this.Controls.Add(fb);

      //Auftragslisten erstellen und in ObjectListViews laden.
      // DB PARALLEL im Background (NON-BLOCKING!)
      _ = Task.Run(async () =>
      {
        try
        {
          await GetAuftraegeAsync(null);

          // UI-Update NACH Daten (Invoke!)
          if (this.IsHandleCreated && !this.IsDisposed)
          {
            this.BeginInvoke(new Action(() =>
            {
              // OLVs füllen
              if (listAuftragToday.Count > 0) Load_OLV(this.objectListViewAuftrag, listAuftragToday);
              if (listAuftragGeschaeft != null && listAuftragGeschaeft.Count > 0) Load_OLV(this.objectListViewGeschaeft, listAuftragGeschaeft);
              if (listSonderAuftrag.Count > 0) Load_OLV(this.objectListViewSonder, listSonderAuftrag);
              if (listVorbereitet != null && listVorbereitet.Count > 0) Load_OLV(this.objectListViewVorbereitet, listVorbereitet);
              if (listRampe != null && listRampe.Count > 0) Load_OLV(this.objectListViewRampe, listRampe);

              // Controls aktivieren und deaktivieren nach BenutzerRolle
              Enable_Controls();

            }));
          }
          else
          {
            // OLVs füllen
            if (listAuftragToday.Count > 0) Load_OLV(this.objectListViewAuftrag, listAuftragToday);
            if (listAuftragGeschaeft != null && listAuftragGeschaeft.Count > 0) Load_OLV(this.objectListViewGeschaeft, listAuftragGeschaeft);
            if (listSonderAuftrag.Count > 0) Load_OLV(this.objectListViewSonder, listSonderAuftrag);
            if (listVorbereitet != null && listVorbereitet.Count > 0) Load_OLV(this.objectListViewVorbereitet, listVorbereitet);
            if (listRampe != null && listRampe.Count > 0) Load_OLV(this.objectListViewRampe, listRampe);

            // Controls aktivieren und deaktivieren nach BenutzerRolle
            Enable_Controls();

          }
        }
        catch (Exception ex)
        {
          // Vermeide $ für C# älter
          Random rnd = new Random();
          int zahl = rnd.Next(1, 10001);
          this.BeginInvoke(new Action(() => MessageBox.Show(string.Format($"Laden fehlgeschlagen. Leite den Fehler {zahl} an Kilian weiter. ", ex.Message))));
          Program.AddFehler(this.benutzer, $"Fehler {zahl} - ex.Message", ex.StackTrace, null);
        }
      });
    }
    private void FormExpedit_FormClosing(object sender, FormClosingEventArgs e)
    {
      _settings.Load();

      // === SPEICHERN DES OLV-STATUS ===
      _settings.OLV_State = this.objectListViewAuftrag.SaveState();
      _settings.OLV_Rampe_State = this.objectListViewRampe.SaveState();
      _settings.OLV_Geschaeft_State = this.objectListViewGeschaeft.SaveState();
      _settings.OLV_Sonder_State = this.objectListViewSonder.SaveState();
      _settings.OLV_Vorbereitet_State = this.objectListViewVorbereitet.SaveState();

      _settings.Save();
    }
    private void FormExpedit_Resize(object sender, EventArgs e)
    {
      this.tabControlAuftragList.Width = this.ClientSize.Width;
    }

    /// <summary>
    /// Wenn FormExpedit angezeigt wird, wird die Location des FeedbackButtons berechnet.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void FormExpedit_Shown(object sender, EventArgs e)
    {
      // Location des Feedback Buttons wird berechnet. (Screengröße ist hier klar)
      UCFeedback fb = this.Controls.Find("feedback", false)[0] as UCFeedback;
      Button btn = fb.Controls[0] as Button;
      if (fb != null) fb.Location = new Point(this.ClientSize.Width - fb.Width, 0);
      btn.BackColor = Program.Wirlblau;
      btn.ForeColor = Color.White;
      btn.FlatAppearance.BorderColor = Color.White;
      fb.BringToFront();

      //WindowState = FormWindowState.Maximized;
     }
    #endregion

    #region Button_Click-Events
    private async void ButtonNeuerAuftrag_Click(object sender, EventArgs e)
    {
      AuftragTyp? auftragTyp = null;

      CustomMessageBox messageBox = new CustomMessageBox("Titel.Auswahl", "Text.Auswahl.Auftrag", null, new string[] { "Geschäft", "Abbrechen", "Standart" });
      if (messageBox.ShowDialog() == DialogResult.Ignore)
      {
        auftragTyp = (AuftragTyp?)Enum.Parse(typeof(AuftragTyp), messageBox.buttontext);

        FormNeuerAuftrag neuerAuftrag = new FormNeuerAuftrag(benutzer, this.letzterLiefertag, auftragTyp);
        if (neuerAuftrag.ShowDialog() == DialogResult.OK)
        {
          this.letzterLiefertag = neuerAuftrag.letzterLiefertag;
          await GetAuftraegeAsync(ListenArt.Auftragliste);
          await GetAuftraegeAsync(ListenArt.Geschäftliste);
          //List<Auftrag> auftraglist = Auftrag.GetAuftragListToday(DateTime.Today);
          OLV_SetObjects(this.objectListViewAuftrag, listAuftragToday);
          OLV_SetObjects(this.objectListViewGeschaeft, listAuftragGeschaeft);
        }
      }
    }
    private void ButtonSWS_Drucken_Click(object sender, EventArgs e)
    {
      Kunde knd = Funktionen.KundenAuswahl();
      if(knd != null) Funktionen.SWS_Drucken(null, knd, this);
    }    
    private void ButtonEinstellung_Click(object sender, EventArgs e)
    {
      FormEinstellung einstellung = new FormEinstellung(this.benutzer);
      einstellung.ShowDialog();
    }
    private void ButtonGetKundeVW_Click(object sender, EventArgs e)
    {
      FormKundeVW kundeVW = new FormKundeVW(this.benutzer);
      kundeVW.ShowDialog();
    }
    private void ButtonReklamation_Click(object sender, EventArgs e)
    {
      FormFehlmengeCount reklamation = new FormFehlmengeCount(this.benutzer);
      reklamation.ShowDialog();
    }
    private void ButtonTourenListe_Click(object sender, EventArgs e)
    {
      List<Benutzer> fahrerliste = Benutzer.GetFahrerList();
      Benutzer fahrer;
      FormBenutzerVW benutzerVW = new FormBenutzerVW(fahrerliste);
      if (benutzerVW.ShowDialog() == DialogResult.OK)
      {
        fahrer = benutzerVW.user;
      }
      else fahrer = null;
      
      if (fahrer != null)
      {
        //List<Auftrag> auftragliste = Auftrag.GetTourenListe(fahrer);
        //if (auftragliste.Count > 0) Funktionen.TourenListe_Drucken(auftragliste, fahrer, this, this.benutzer);
      }

    }
    private void ButtonStats_Click(object sender, EventArgs e)
    {
      FormShowUserControl showGroupBox = new FormShowUserControl("Statistik", this.benutzer);
      showGroupBox.ShowDialog();
    }
    private void ButtonEtikettenDrucken_Click(object sender, EventArgs e)
    {
      ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
      if (olv.SelectedItems.Count == 0 || olv.SelectedItems.Count > 1) return;
      View_Auftrag_Expedit view = (View_Auftrag_Expedit)olv.SelectedItem.RowObject;
      Auftrag auftrag = Auftrag.GetAuftrag(view.AuftragID);

      this.UseWaitCursor = true;

      HandleEtikettClick(auftrag);

      Neuladen_OLV(olv);
      this.UseWaitCursor = false;

    }
    private void ButtonNW_Click(object sender, EventArgs e)
    {
      FormArtikelVW artikelVW = new FormArtikelVW(this.benutzer);
      artikelVW.ShowDialog();
    }
    private void ContextMenuStripBearbeiten_Click(object sender, EventArgs e)
    {
      ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
      ToolStripItem item = (ToolStripItem)sender;
      string aspect = item.AccessibleName;
      var col = olv.AllColumns.OfType<OLVColumn>().First(x => x.AspectName == aspect);
      if (this.benutzer.Rolle == BenutzerRolle.Admin) col.IsEditable = true;

      if (olv.SelectedItem != null)
      {
        TrelloKarte = true;
        int idx = col.Index;
        olv.StartCellEdit(olv.SelectedItem, idx);
      }

    }
    private void ContextMenuStripAufgabeErledigt_Click(object sender, EventArgs e)
    {
      ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
      // Überprüfung ob Click auf einem Item war.
      if (olv.SelectedObject == null) return;
      Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)olv.SelectedObject).AuftragID);
      Kunde _kunde = Kunde.GetKunde(null, _auftrag.KundeID, null);
      string name;
      if (string.IsNullOrWhiteSpace(_kunde.Suchtext)) name = _kunde.KundeName;
      else name = _kunde.Suchtext;

      if (_auftrag.AufgabeID == null) return;
      Aufgabe _aufgabe = Aufgabe.GetAufgabe(null, _auftrag.AufgabeID);
      if (meldung.GetFrage(this, $"Hast du beim Kunden {name} die Aufgabe {_aufgabe.Bezeichnung} erledigt?", false) == DialogResult.Yes)
      {
        Aufgabe_erledigt(_auftrag, _kunde, name);
      }

    }
    private void ContextMenuStripAuftragVerschieben_Click(object sender, EventArgs e)
    {
      ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
      if (!olv.Name.Contains("Rampe")) return;
      // Überprüfung ob Click auf einem Item war.
      if (olv.SelectedObject == null) return;
      Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)olv.SelectedObject).AuftragID);

      if (_auftrag == null) return;
      _auftrag.Status = AuftragStatus.Gewaschen;
      _auftrag.Save();

      Neuladen_OLV(olv);
    }
    private void ContextMenuStripAuftragDelete_Click(object sender, EventArgs e)
    {
      ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
      // Überprüfung ob Click auf einem Item war.
      if (olv.SelectedObject == null) return;
      Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)olv.SelectedObject).AuftragID);

      if (_auftrag == null) return;
      string knd = ((View_Auftrag_Expedit)olv.SelectedObject).KundeName;

      if (CustomMessageBox.Show("Titel.Frage", "Text.Frage.AuftragLoeschen", null, new string[] { "Ja", "Nein" }) == DialogResult.No) return;
      else
      {
        _auftrag.Delete();
        Neuladen_OLV(olv);
      }
    }
    private void ContextMenuStripAuftragInfo_Click(object sender, EventArgs e)
    {
      ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
      // Überprüfung ob Click auf einem Item war.
      if (olv.SelectedObject == null) return;
      Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)olv.SelectedObject).AuftragID);

      if (_auftrag == null) return;

      FormShowUserControl showUserControl = new FormShowUserControl("AuftragInfo", this.benutzer, _auftrag);
      showUserControl.Show();

    }
    private void ContextMenuStripAbteilungStatus_Click(object sender, EventArgs e)
    {
      ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
      ToolStripItem item = (ToolStripItem)sender;
      // Überprüfung ob Click auf einem Item war.
      if (olv.SelectedObject == null) return;
      Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)olv.SelectedObject).AuftragID);

      if (_auftrag == null) return;
      if (item.AccessibleName == "Kleinteile") { _auftrag.Abteilungen |= AbteilungsStatus.KleinteileBeendet; _auftrag.Save(); }
      if (item.AccessibleName == "Grossteile") { _auftrag.Abteilungen |= AbteilungsStatus.GrossteileBeendet; _auftrag.Save(); }
      if (item.AccessibleName == "Frottee") { _auftrag.Abteilungen |= AbteilungsStatus.FrotteeBeendet; _auftrag.Save(); }
      if (item.AccessibleName == "Spannleintuch") { _auftrag.Abteilungen |= AbteilungsStatus.SpannleintuchBeendet; _auftrag.Save(); }

      Neuladen_OLV(olv);
    }


    #endregion
    private void ContextMenuStrip_DropDownOpening(object sender, EventArgs e)
    {
      ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
      ToolStripMenuItem tsi = (ToolStripMenuItem)sender;
      foreach (ToolStripDropDownItem item in tsi.DropDownItems)
      {
        if (item.AccessibleName == null) continue;
        string aspect = item.AccessibleName;
        var col = olv.AllColumns.OfType<OLVColumn>().First(x => x.AspectName == aspect);
        if (col.IsEditable) item.Enabled = true;
        else item.Enabled = false;
      }

      // MenuItem Abteilungen Status Enablen oder Disablen
      ToolStripMenuItem menuitem = (ToolStripMenuItem)tsi.DropDownItems[5];
      var varcol = olv.AllColumns.OfType<OLVColumn>().First(x => x.AspectName == "KleinteileAnzeige");
      if (varcol.IsEditable) menuitem.Enabled = true;
      else menuitem.Enabled = false;

    }
    private void ContextMenuStripExpedit_Opening(object sender, System.ComponentModel.CancelEventArgs e)
    {
      ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
      olv.CellEditFinished += ObjectListViewAuftrag_CellEditFinished;
      if (olv.SelectedObject == null) return;
      Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)olv.SelectedObject).AuftragID);

      // Überprüfen ob ObjectListView Rampe ist.
      if (!olv.Name.Contains("Rampe")) this.auftragVerschiebenToolStripMenuItem.Enabled = false;
      else this.auftragVerschiebenToolStripMenuItem.Enabled = true;
      // Überprüfen ob Auftrag eine Aufgabe hat.
      if (_auftrag.AufgabeID == null) this.aufgabeErledigtToolStripMenuItem.Enabled = false;
      else this.aufgabeErledigtToolStripMenuItem.Enabled = true;
      // Überprüfen ob User Admin ist.
      if (this.benutzer.Rolle != BenutzerRolle.Admin & this.benutzer.Rolle != BenutzerRolle.Master) this.auftragLöschenToolStripMenuItem.Enabled = false;
      else this.auftragLöschenToolStripMenuItem.Enabled = true;
    }


    #region ObjectListView-Events

    private void Load_OLV(ObjectListView olv, List<View_Auftrag_Expedit> auftragliste)
    {
      this.UseWaitCursor = true;

      // === LAYOUT & UPDATE PAUSIEREN ===
      olv.BeginUpdate();
      olv.SuspendLayout();

      try
      {
        // === SPALTEN NUR EINMAL GENERIEREN (falls sinnvoll) ===
        if (olv.AllColumns.Count == 0)
        {
          Generator.GenerateColumns(olv, typeof(View_Auftrag_Expedit), true);
          ConfigureColumns(olv);
        }

        // === IMAGE-LIST (einmalig zentral konfigurieren, hier nur zuweisen) ===
        Program.imagelist.ImageSize = new Size(24, 24);
        olv.SmallImageList = Program.imagelist;

        // === TOOLTIP-EVENT EINMALIG REGISTRIEREN ===
        olv.CellToolTipShowing -= Olv_CellToolTipShowing;
        olv.CellToolTipShowing += Olv_CellToolTipShowing;

        // === DATEN LADEN ===
        OLV_SetObjects(olv, auftragliste);

        // === SORTIERUNG ===
        var statusCol = olv.AllColumns.Cast<OLVColumn>().FirstOrDefault(c => c.Text == "Status");
        var liefertagCol = olv.AllColumns.Cast<OLVColumn>().FirstOrDefault(c => c.Text == "Liefertag");

        if (statusCol != null) olv.PrimarySortColumn = statusCol;
        if (liefertagCol != null) olv.SecondarySortColumn = liefertagCol;

        if (olv.Name.Contains("Rampe") && liefertagCol != null)
          olv.Sort(liefertagCol);
        else
          olv.Sort();

        // === SPALTEN JE NACH TAB/ROLLE ===
        GetUnvisibleColumns(olv);

        // === RESTORE OLV-STATUS ===
        if (olv.Name.Contains("Auftrag") && _settings.OLV_State != null && _settings.OLV_State.Length > 0) this.objectListViewAuftrag.RestoreState(_settings.OLV_State);
        if (olv.Name.Contains("Rampe") && _settings.OLV_Rampe_State != null && _settings.OLV_Rampe_State.Length > 0) this.objectListViewRampe.RestoreState(_settings.OLV_Rampe_State);
        if (olv.Name.Contains("Vorbereitet") && _settings.OLV_Vorbereitet_State != null && _settings.OLV_Vorbereitet_State.Length > 0) this.objectListViewVorbereitet.RestoreState(_settings.OLV_Vorbereitet_State);
        if (olv.Name.Contains("Sonder") && _settings.OLV_Sonder_State != null && _settings.OLV_Sonder_State.Length > 0) this.objectListViewSonder.RestoreState(_settings.OLV_Sonder_State);
        if (olv.Name.Contains("Geschaeft") && _settings.OLV_Geschaeft_State != null && _settings.OLV_Geschaeft_State.Length > 0) this.objectListViewGeschaeft.RestoreState(_settings.OLV_Geschaeft_State);

        // === SPALTENBREITE ANPASSEN ===
        olv = Funktionen.Columns_Resize(null, olv).olv;

        // === FILTER ===
        olv.FilterMenuBuildStrategy = new MeinFilterMenu();
      }
      finally
      {
        olv.ResumeLayout();
        olv.EndUpdate();
        olv.Focus();
        this.UseWaitCursor = false;
      }
    }
    private void ConfigureColumns(ObjectListView olv)
    {
      var columns = olv.AllColumns.Cast<OLVColumn>().ToList();

      OLVColumn Find(string header) =>
          columns.FirstOrDefault(c => String.Equals(c.Text, header, StringComparison.OrdinalIgnoreCase));

      // --- Typ-String ---
      var typColumn = Find("Typ"); 
      typColumn.AspectToStringConverter = delegate (object x)
      {
        if (x == null) return string.Empty;

        var typ = (AuftragTyp)x;
        if (typ == AuftragTyp.Standart)
          return string.Empty;

        return typ.ToString();
      };

      // --- Aufgabe-Icon ---
      var aufgabeCol = Find("Aufgabe");
      if (aufgabeCol != null)
      {
        aufgabeCol.ImageGetter = rowObject =>
        {
          if (!(rowObject is View_Auftrag_Expedit a)) return -1;
          return string.IsNullOrEmpty(a.AufgabeBezeichnung) ? -1 : 0;
        };
      }

      // --- Kunde-Icon ---
      var kundeCol = Find("Kunde");
      if (kundeCol != null)
      {
        kundeCol.ImageGetter = rowObject =>
        {
          if (!(rowObject is View_Auftrag_Expedit a)) return -1;
          return string.IsNullOrEmpty(a.Zusatz) ? -1 : 1;
        };
        
      }

      // ---Tour-AspectName ---
      var tourCol = Find("TourID");
      if (tourCol != null)
      {
        tourCol.AspectName = "Tour";
      }

      // --- Schmutzig / Sauber ---
      var dirtCol = Find("Schmutzig");
      if (dirtCol != null)
      {
        dirtCol.HeaderImageKey = "dirt";
        dirtCol.ShowTextInHeader = false;
        dirtCol.MinimumWidth = dirtCol.MaximumWidth = 80;
      }
      var cleanCol = Find("Sauber");
      if (cleanCol != null)
      {
        cleanCol.HeaderImageKey = "clean";
        cleanCol.ShowTextInHeader = false;
        cleanCol.MinimumWidth = cleanCol.MaximumWidth = 80;
      }

      // --- Abschließen-Button ---
      var fertigCol = Find("Abschließen");
      if (fertigCol != null)
      {
        fertigCol.IsButton = true;
        fertigCol.ButtonSizing = OLVColumn.ButtonSizingMode.CellBounds;
        fertigCol.HeaderImageKey = "abschließen";
        fertigCol.ShowTextInHeader = false;
        fertigCol.MinimumWidth = fertigCol.MaximumWidth = 80;
      }


      foreach (OLVColumn col in columns)
      {
        switch (this.benutzer.Rolle)
        {
          case BenutzerRolle.Verwaltung:
            break;
          case BenutzerRolle.Fahrer:
            break;
          case BenutzerRolle.Admin: if (col.AspectName is "ContainerDirt" || col.AspectName is "Liefertag" || col.AspectName is "ContainerClean" || col.AspectName is "Status" || col.AspectName is "Tour" || col.AspectName is "FrotteeAnzeige" || col.AspectName is "KleinteileAnzeige" || col.AspectName is "GrossteileAnzeige") col.IsEditable = true;
            break;
          case BenutzerRolle.Waschstrasse:
            break;
          case BenutzerRolle.Master:
            break;
          case BenutzerRolle.Expedit: if (col.AspectName is "ContainerClean" || col.AspectName is "Liefertag" || col.AspectName is "Tour") col.IsEditable = true;
            break;
          case BenutzerRolle.Frottee:
            break;
          case BenutzerRolle.Flach:
            break;
          default:
            break;
        }
      }
    }
    private void Olv_CellToolTipShowing(object sender, ToolTipShowingEventArgs e)
    {
      // Kein Model, kein Tooltip
      if (e.Model == null || e.Column == null)
        return;

      // Aufgabe-Tooltip
      if (e.Column.Text == "Aufgabe" && e.Model is View_Auftrag_Expedit expeditAufgabe)
      {
        //var auftrag = Auftrag.GetAuftrag(expeditAufgabe.AuftragID);
        //var aufgabe = Aufgabe.GetAufgabe(null, expeditAufgabe.AufgabeID);
        e.Text = expeditAufgabe.AufgabeBeschreibung;
        return;
      }

      // Kunde-Tooltip
      if (e.Column.Text == "Kunde" && e.Model is View_Auftrag_Expedit expeditKunde)
      {
        //var auftrag = Auftrag.GetAuftrag(expeditKunde.AuftragID);
        //var kunde = Kunde.GetKunde(null, expeditKunde.KundeID, null);
        if (!string.IsNullOrWhiteSpace(expeditKunde.KundeAnmerkung))
          e.Text = expeditKunde.KundeAnmerkung;
        else e.Text = expeditKunde.Zusatz;
        return;
      }

      // Typ-Tooltip
      if (e.Column.Text == "Typ" && e.Model is View_Auftrag_Expedit expeditTyp)
      {
        //var auftrag = Auftrag.GetAuftrag(expeditTyp.AuftragID);
        if (e.SubItem.Text == "Laufzettel") e.Text = expeditTyp.Zusatz;
        return;
      }

      // Fahrer-Tooltip – Typfix: hier passt View_Auftrag_Expedit besser
      if (e.Column.Text == "Fahrer" && e.Model is View_Auftrag_Expedit expeditFahrer)
      {
        e.Text = expeditFahrer.Zusatz;
      }
    }
    private void ObjectListViewAuftrag_FormatCell(object sender, FormatCellEventArgs e)
    {
      ObjectListView olv = sender as ObjectListView;

      // Button Spalte immer mit Hintergrund damit besser sichtbar.
      if (e.Column.IsButton)
      {
        if(e.SubItem.BackColor != Color.LightBlue)
        {
          e.SubItem.BackColor = Color.AliceBlue;
          e.SubItem.ForeColor = Color.Black;
        }
        else
        {
          e.SubItem.BackColor = Color.LightSteelBlue;
          e.SubItem.ForeColor = Color.Black;

        }
      }

      // Abteilungstatus wird farblich gekennzeichnet
      if (e.Column.Text == "FR" || e.Column.Text == "KT" || e.Column.Text == "GT" || e.Column.Text == "SL")
      {
        if (e.CellValue.ToString() == "☑")
        {
          e.SubItem.Font = new Font("Segoe UI Symbol", 14F, FontStyle.Bold);
          if (e.SubItem.BackColor == Color.YellowGreen) e.SubItem.ForeColor = Color.Black;
          else e.SubItem.ForeColor = Color.YellowGreen;
        }
        if (e.CellValue.ToString() == "☐")
        {
          e.SubItem.Font = new Font("Segoe UI Symbol", 14F, FontStyle.Bold);
          e.SubItem.ForeColor = Color.Yellow;

          // Wenn FrotteeExpedit und FrotteeAbteilung ist in Bearbeitung dann Zeile Gelb hinterlegen.
          if (this.benutzer.Rolle == BenutzerRolle.Frottee && e.Column.Text == "FR") 
          {
            foreach (OLVListSubItem sitem in e.Item.SubItems)
            {
              sitem.BackColor = Color.Yellow;
            }
            e.SubItem.ForeColor = Color.Black;
            e.Item.BackColor = Color.Yellow;
          }
          
        }
        if (e.CellValue.ToString() == "☒")
        {
          e.SubItem.Font = new Font("Segoe UI Symbol", 14F, FontStyle.Bold);
          e.SubItem.ForeColor = Color.Red;
        }

      }

      if (e.Column.Text == "Liefertag")
      {
        if (DateTime.TryParse(e.CellValue.ToString(), out DateTime dt))
        {
          if (dt < DateTime.Today) e.SubItem.ForeColor = Color.Red;
        }
      }

    }
    private void ObjectListViewAuftrag_FormatRow(object sender, FormatRowEventArgs e)
    {
      bool isFertig = false;
      ObjectListView olv = sender as ObjectListView;
      View_Auftrag_Expedit vwAuftrag = e.Model as View_Auftrag_Expedit;

      if (vwAuftrag.FrotteeStatus > 1 & vwAuftrag.KleinteileStatus > 1 & vwAuftrag.GrossteileStatus > 1 & vwAuftrag.SpannleintuchStatus > 1) isFertig = true;
      if (vwAuftrag.FrotteeStatus > 2 & vwAuftrag.KleinteileStatus > 2 & vwAuftrag.GrossteileStatus > 2 & vwAuftrag.SpannleintuchStatus > 2) isFertig = false;

      if (this.benutzer.Rolle != BenutzerRolle.Frottee & isFertig)
      {
        foreach (OLVListSubItem subitem in e.Item.SubItems)
        {
          subitem.BackColor = Color.YellowGreen;
        }
      }
    }

    private async void ObjectListViewAuftrag_CellClick(object sender, CellClickEventArgs e)
    {
      itemlocation = new Point(e.Location.X, e.Location.Y);
      ObjectListView olv = (ObjectListView)sender;
      View_Auftrag_Expedit expAuftrag;
      if (e.Model == null) { chartFehlmenge.Visible = false; groupBoxKndInfo.Visible = false; return; }
      else expAuftrag = (View_Auftrag_Expedit)e.Model;
      Auftrag _auftrag = Auftrag.GetAuftrag(expAuftrag.AuftragID);

      if (expAuftrag.FrotteeStatus == 1 || expAuftrag.KleinteileStatus == 1 || expAuftrag.GrossteileStatus == 1 || expAuftrag.SpannleintuchStatus == 1) ToPrint = false;
      else ToPrint = true;

      if (_auftrag.Status != AuftragStatus.Fertig)
      {
        this.auftrag = _auftrag;
        this.kunde = Kunde.GetKunde(null, this.auftrag.KundeID, null);
        this.artikelListe = KundeArtikel.GetList(kunde.KundeID.ToString());

        // Chart wird eingeblendet statt Gridview. NUR wenn isttest = true.
        var chartliste = await KundeArtikel.LoadArtikelDatenAsync(kunde);
        if (chartliste.Count > 0)
        {
          this.chartFehlmenge = Funktionen.Load_FehlmengeChart(chartliste, chartFehlmenge);
          this.chartFehlmenge.Visible = true;
        }
        else this.chartFehlmenge.Visible = false;
        if (!string.IsNullOrWhiteSpace(this.kunde.Anmerkung) || auftrag.AufgabeID != null) this.groupBoxKndInfo.Visible = true;
        else this.groupBoxKndInfo.Visible = false;
        if (!string.IsNullOrWhiteSpace(this.kunde.Anmerkung))
        {
          labelAnmerkung.Visible = true;
          labelAnmerkung.Text = this.kunde.Anmerkung;
        }
        else { labelAnmerkung.Visible = false; }
        if (auftrag.AufgabeID != null)
        {
          labelAufgabe.Text = Aufgabe.GetAufgabe(null, auftrag.AufgabeID).Bezeichnung.ToString();
          labelAufgabe.Visible = true;
        }
        else { labelAufgabe.Visible = false; }
        if (auftrag.ZusatzInfo != null)
        {
          labelZusatz.Text = auftrag.ZusatzInfo;
          labelZusatz.Visible = true;
        }
        else { labelZusatz.Visible = false; }

        // GroupBox einblenden wenn notwendig.
        if (labelAufgabe.Visible || labelAnmerkung.Visible || chartFehlmenge.Visible || labelZusatz.Visible) this.groupBoxKndInfo.Visible = true;
        else this.groupBoxKndInfo.Visible = false;

      }
      else
      {
        if (e.ClickCount == 1) fehlermeldung.AuftragFertig();
      }

      olv.Focus();
      
    }
    private void ObjectListViewAuftrag_ButtonClick(object sender, CellClickEventArgs e)
    {
      var olv = (ObjectListView)sender;
      var view = (View_Auftrag_Expedit)e.Model;
      var auftrag = Auftrag.GetAuftrag(view.AuftragID);

      this.UseWaitCursor = true;

      try
      {
        switch (e.Column.Text)
        {
          case "Abschließen":
            HandleAbschliessenClick(olv, auftrag);
            break;

          case "Etikett":
            HandleEtikettClick(auftrag);
            break;
        }
      }
      finally
      {
        Neuladen_OLV(olv);
        this.UseWaitCursor = false;
      }
    }
    private void ObjectListView_DoubleClick(object sender, EventArgs e)
    {
      ObjectListView olv = (ObjectListView)sender;
      olv.CellEditFinished -= ObjectListViewAuftrag_CellEditFinished;
      Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)olv.SelectedObject).AuftragID);
      Kunde _kunde = Kunde.GetKunde(null, _auftrag.KundeID, null);

      // Wenn NICHT erfasster Kunde dann nichts öffnen.
      if (_kunde.KundeNummer == "2320000") return;

      if (_auftrag.Typ is AuftragTyp.Standart || _auftrag.Typ is AuftragTyp.Geschäft || _auftrag.Typ is AuftragTyp.AufAbruf || olv.Name.Contains("Vorbereitet"))
      {
        if (_auftrag == null) return;

        FormKundeVW kndVW = new FormKundeVW(_kunde, this.benutzer);
        if (kndVW.ShowDialog() == DialogResult.OK)
        {
          if (kndVW.aufgabeErledigt) Aufgabe_erledigt(_auftrag, _kunde, _kunde.Suchtext ?? _kunde.KundeName);

        }
        return;
      }
      else
      {
        FormAuftragDetail auftragDetail = new FormAuftragDetail(_auftrag, this.benutzer);
        if (auftragDetail.ShowDialog() == DialogResult.OK)
        {
          Neuladen_OLV(olv);
        }
        return;
      }
    }

    /// <summary>
    /// Behandelt den Fall, dass der Button in der Spalte Abschliessen geclickt wurde
    /// </summary>
    /// <param name="olv"></param>
    /// <param name="auftrag"></param>
    private void HandleAbschliessenClick(ObjectListView olv, Auftrag auftrag)
    {
      // Sonderfall Frottee: nur Abteilung beenden und raus
      if (this.benutzer.Rolle == BenutzerRolle.Frottee)
      {
        this.auftrag = auftrag;
        Auftrag_Fertig();
        return;
      }

      if (olv.CheckedItems.Count > 0)
      {
        HandleBatchAbschliessen(olv);
        return;
      }

      HandleSingleAbschliessen(auftrag);
    }

    /// <summary>
    /// Wenn angehackte Datensätze im Bulk abeschlossen werden sollen.
    /// Hier sind mehrere oder nur ein Auftrag abschließen möglich.
    /// </summary>
    /// <param name="olv"></param>
    private void HandleBatchAbschliessen(ObjectListView olv)
    {
      var count = olv.CheckedItems.Count;
      var result = CustomMessageBox.Show("Titel.Frage", "Text.Frage.BatchAbschließen", null, new string[] { "Ja", "Nein" });

      if (result == DialogResult.No)
        return;

      foreach (OLVListItem item in olv.CheckedItems)
      {
        this.auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)item.RowObject).AuftragID);
        Auftrag_Fertig();
      }

      var kundeColumn = olv.AllColumns
          .Cast<OLVColumn>()
          .FirstOrDefault(col => col.Text == "Kunde");

      if (kundeColumn != null && kundeColumn.HeaderCheckBox)
        olv.UncheckHeaderCheckBox(kundeColumn);
    }

    /// <summary>
    /// Wenn der Button geclickt wurde ohne anhacken. Es wird garantiert nur 1 Auftrag abgeschlossen
    /// </summary>
    /// <param name="auftrag"></param>
    private void HandleSingleAbschliessen(Auftrag auftrag)
    {
      if (this.auftrag != auftrag)
        altecontclean = null;

      this.auftrag = auftrag;

      if (!HandleContainerCleanChange())
        return;

      Auftrag_Fertig();
    }

    /// <summary>
    /// Behandelt den Fall, dass sich ContainerClean geändert hat.
    /// Gibt false zurück, wenn der Vorgang abgebrochen werden soll.
    /// </summary>
    private bool HandleContainerCleanChange()
    {
      if (altecontclean == null || this.auftrag.ContainerClean == altecontclean)
        return true;

      switch (meldung.DifferentCleanContainer())
      {
        case DialogResult.Cancel:
          return false;

        case DialogResult.Yes:
          return TryDruckMitNeuemContainerClean();

        case DialogResult.No:
          this.auftrag.Erstellt = DateTime.Now;
          this.auftrag.ErstelltVon = (int)benutzer.BenutzerID;
          return true;

        default:
          return true;
      }
    }

    /// <summary>
    /// Wenn eine neue Anzahl an sauberen Containern eingegeben wurde wird ein erneuter Druck abgefragt.
    /// </summary>
    private bool TryDruckMitNeuemContainerClean()
    {
      this.auftrag.Gedruckt = DateTime.Now;
      this.auftrag.GedrucktVon = benutzer.BenutzerID;

      var nocont = false;

      if (this.auftrag.ContainerClean > 10)
      {
        var res = CustomMessageBox.Show("Titel.Frage", "Text.Frage.EtikettContainer", null, new string[] { "Ja", "Nein" });
        nocont = (res == DialogResult.No);
      }

      try
      {
        Funktionen.Etikett_Drucken(auftrag, nocont);
        return true;
      }
      catch (Exception ex)
      {
        CustomMessageBox.Show("Titel.Fehler", "Text.Fehler.Drucken", "ToDo.DruckFehler", new string[] { "Ok" });

        Program.AddFehler(this.benutzer, ex.Message, ex.StackTrace, null);
        return false;
      }
    }

    /// <summary>
    /// Behandelt den Fall, dass der Button in der Spalte Etikett geclickt wurde.
    /// </summary>
    /// <param name="auftrag"></param>
    private void HandleEtikettClick(Auftrag auftrag)
    {
      this.auftrag = auftrag;

      if (this.auftrag.AufgabeID != null)
      {
        var aufgabe = Aufgabe.GetAufgabe(null, auftrag.AufgabeID);
        var text = $"Bei dem ausgewählten Auftrag ist die Aufgabe {aufgabe.Bezeichnung} zu erledigen. Hast du die Aufgabe erledigt? ";

        if (meldung.GetAchtung(this, text, false) == DialogResult.No) return;
        else
        {
          Kunde _kunde = Kunde.GetKunde(null, this.auftrag.KundeID, null);
          string name;
          if (string.IsNullOrWhiteSpace(_kunde.Suchtext)) name = _kunde.KundeName;
          else name = _kunde.Suchtext;

          this.auftrag.Erledigt = DateTime.Now;
          this.auftrag.ErledigtVon = (int)this.benutzer.BenutzerID;
          Aufgabe_erledigt(this.auftrag, _kunde, name);
        }
      }
      
      if (this.auftrag.Typ < AuftragTyp.Inventur || (this.auftrag.Typ >= AuftragTyp.Inventur && this.auftrag.ContainerClean > 0))
      {
        var rslt = DialogResult.None;
        PrepareContainerCleanForEtikett();

        if (this.auftrag.ContainerClean == 0)
        {
          CustomMessageBox messageBox = new CustomMessageBox("Titel.Frage", "Text.Frage.ContainerSauberNull", null, new string[] { "Ja", "Nein", "Abbrechen" });
          rslt = messageBox.ShowDialog();
        }

        switch (rslt)
        {
          case DialogResult.Cancel: 
            return;
          case DialogResult.Yes:
            goto default;
          case DialogResult.No:
            break;
          default:
            var result = Funktionen.Etikett_Drucken(auftrag, nocont);
            if (result == DialogResult.OK)
            {
              this.auftrag.Gedruckt = DateTime.Now;
              this.auftrag.GedrucktVon = (int)this.benutzer.BenutzerID;
            }
            break;
        }

      }

      this.auftrag.Status = AuftragStatus.Vorbereitet;
      this.auftrag.Save();
      this.auftrag = null;

    }

    private void PrepareContainerCleanForEtikett()
    {
      string eingabe;
      if (this.auftrag.ContainerClean != 0)
      {
        letzterLiefertag = this.auftrag.Liefertag;
        return;
      }
      CustomInputBox inputBox = new CustomInputBox("Titel.Frage", "Text.Frage.ContainerAnzahl", "ToDo.ContainerAnzahl", "Containeranzahl", "isNumeric");
      if (inputBox.ShowDialog() == DialogResult.OK)
      {
        eingabe = inputBox.text;
      }
      else eingabe = string.Empty;

      if (string.IsNullOrWhiteSpace(eingabe) || !int.TryParse(eingabe, out int anzahl))
      {
        this.UseWaitCursor = false;
        return;
      }

      this.auftrag.ContainerClean = anzahl;
    }
    /// <summary>
    /// Die Objecte der ObjectListView werden neu geladen.
    /// </summary>
    /// <param name="olv"></param>
    /// <param name="auftraglist"></param>
    private void OLV_SetObjects(ObjectListView olv, List<View_Auftrag_Expedit> auftraglist)
    {
      if (olv.AllColumns.Count == 0) Load_OLV(olv, auftraglist);
      else
      {
        olv.SetObjects(auftraglist);  // Bindet die Auftragsliste an die View
      }
    }
    
    /// <summary>
    /// Die Objecte der ObjectListView werden neu geladen. Wenn Sie noch keine Spalten hat wird die ObjectListView komplett neu geladen.
    /// </summary>
    /// <param name="olv"></param>
    private async void Neuladen_OLV(ObjectListView olv)
    {
      this.UseWaitCursor = true;
      olv.SuspendLayout();

      // Neu-Laden der ObjectListView
      if (olv.Name.Contains("Geschaeft")) { await GetAuftraegeAsync(ListenArt.Geschäftliste); OLV_SetObjects(olv, listAuftragGeschaeft); }
      if (olv.Name.Contains("Auftrag")) { await GetAuftraegeAsync(ListenArt.Auftragliste); OLV_SetObjects(olv, listAuftragToday); }
      if (olv.Name.Contains("Rampe")) { await GetAuftraegeAsync(ListenArt.Rampenliste); OLV_SetObjects(olv, listRampe); }
      if (olv.Name.Contains("Vorbereitet")) { await GetAuftraegeAsync(ListenArt.Vorbereitetliste); OLV_SetObjects(olv, listVorbereitet); }
      if (olv.Name.Contains("Sonder")) { await GetAuftraegeAsync(ListenArt.Sonderliste); OLV_SetObjects(olv, listSonderAuftrag); }

      GetUnvisibleColumns(olv);
      olv.ResumeLayout(false);
      this.UseWaitCursor = false;
    }

    /// <summary>
    /// Blendet die Button Spalten aus wenn der User dazu nicht berechtigt ist.
    /// </summary>
    private void GetUnvisibleColumns(ObjectListView olv)
    {
      foreach (OLVColumn col in olv.AllColumns)
      {
        switch (tabControlAuftragList.SelectedTab.Text)
        {
          case var t when t == "Vorbereitet":        //Wenn Tab ist Vorbereitet wird Abschließen eingeblendet.
            if (col.Text == "Abschließen") col.IsVisible = true;
            if (col.Text == "Etikett") col.IsVisible = false;
            if (col.Text == "Kunde")
            {
              col.HeaderCheckBox = true;
              col.HeaderCheckBoxUpdatesRowCheckBoxes = true;
            }
            if (col.Text == "FR" || col.Text == "GT" || col.Text == "KT") col.IsVisible = false;
            break;
          case var t when t == "Rampe":
            if (col.IsButton) col.IsVisible = false;
            if (col.Text == "FR" || col.Text == "GT" || col.Text == "KT" || col.Text == "SL") col.IsVisible = false;
            break;
          case var t when t == "Geschäft":
            if (col.Text == "Abschließen") col.IsVisible = true;
            if (col.Text == "Etikett") col.IsVisible = true;
            break;
          case var t when t == "Aufträge heute":
            if (col.Text == "Abschließen")
            {
              //Für alle BenutzerRollen Abschließen ausblenden.
              //Nur FrotteeExpedit sieht Abschließen um Abteilung zu beenden.
              if (this.benutzer.Rolle == BenutzerRolle.Frottee) col.IsVisible = true;
              else col.IsVisible = false;
            }
            break;
          default:
            break;
        }

        //Für FrotteeExpedit Etiketten drucken ausblenden.
        if (this.benutzer.Rolle == BenutzerRolle.Frottee) if (col.Text == "Etikett" & col.IsButton) col.IsVisible = false;
      }

      olv.RebuildColumns();
    }

    /// <summary>
    /// Cell Edit Finished wird verwendet um die Container Sauber Anzahl festzulegen.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private async void ObjectListViewAuftrag_CellEditFinished(object sender, CellEditEventArgs e)
    {
      ObjectListView olv = (ObjectListView)sender;
      this.auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)e.RowObject).AuftragID);
      var modelType = this.auftrag.GetType();
      var propInfo = modelType.GetProperty(e.Column.AspectName);


      switch (e.Column.AspectName)
      {
        case var t when t == "ContainerClean":
          {
            altecontclean = (int?)e.Value;

            if (e.Value != e.NewValue)
            {
              if (this.auftrag.Status <= AuftragStatus.Warten)
              {
                if (int.TryParse(e.NewValue.ToString(), out int i)) this.auftrag.ContainerClean = i;
                else return;

                if (this.auftrag.Status == AuftragStatus.Vorbereitet)
                {
                  if (CustomMessageBox.Show("Titel.Frage", "Text.Frage.ContainerSauberChanged", null, new string[] { "Ja", "Nein" }) == DialogResult.Yes)
                  {
                    Funktionen.Etikett_Drucken(this.auftrag, nocont);
                  }
                }
              }
            }
          }
          break;
        case var t when t == "Tour":
          { //TODO: Mit Tour statt Fahrer durchgehen.
            if (!string.IsNullOrWhiteSpace(e.NewValue.ToString()))
            {
              Saison saison = Saison.GetAktivSaison();
              Tour tour = Tour.GetTour(saison.SaisonId, e.NewValue.ToString().ToUpper());
              if (tour == null) { e.NewValue = string.Empty; return; }
              this.auftrag.TourID = tour.TourID;
              this.auftrag.Priority = tour.Priority;
              e.NewValue = tour.Bezeichnung;
            }
          }
          break;
        case var t when t == "ContainerDirt":
          {
            if (int.TryParse(e.NewValue.ToString(), out int i)) this.auftrag.Container = i;
            else return;
          }
          break;
        case var t when t == "Liefertag":
          {
            if (this.benutzer.Rolle == BenutzerRolle.Verwaltung || this.benutzer.Rolle == BenutzerRolle.Admin)
            {
              if (!TrelloKarte) return;

              if (_trelloClient == null)
              {
                MessageBox.Show("Bitte zuerst Credentials speichern.", "Fehler",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
              }

              if (CustomMessageBox.Show("Titel.Frage", "Text.Frage.TrelloKarteErstellen", null, new string[] { "Ja", "Nein" }) == DialogResult.No) { TrelloKarte = false; goto default; }

              try
              {
                DateTime oldDate = DateTime.Parse(e.Value.ToString());
                DateTime newDate = DateTime.Parse(e.NewValue.ToString());
                Benutzer _fahrer = Benutzer.GetBenutzer(null, this.auftrag.ErstelltVon);
                Kunde _kunde = Kunde.GetKunde(null, this.auftrag.KundeID, null);
                string kndName = _kunde.KundeName?? _kunde.Suchtext;

                // Wenn kein Fahrer hinterlegt oder keine Tour(Trello-Listen-ID) beim Fahrer wird die Allgmeine-Listen_ID verwendet.
                string listID = _fahrer?.Tour?? "69cf1a3adfbfd598e8d98be9";
                this.auftrag.Liefertag = newDate;

                var options = new CreateCardOptions
                {
                  Name = $"Der Liefertag von {kndName} wurde von {oldDate.Date:d} zu {newDate.Date:d} verschoben.",
                  Desc = "Diese Karte wurde automatisch erstellt. Bitte gegebenenfalls korrigieren.",
                  IdList = $"{listID}",
                  Pos = "top",
                  DueDate = newDate
                };

                var card = _trelloClient.CreateCardAndParseAsync(options);
                TrelloKarte = false;

                //MessageBox.Show(
                //    $"Karte erstellt:\nID: {card.Id}\nName: {card.Name}\nURL: {card.ShortUrl}",
                //    "Erfolg",
                //    MessageBoxButtons.OK,
                //    MessageBoxIcon.Information);
              }
              catch (Exception ex)
              {
                MessageBox.Show($"Fehler beim Erstellen der Karte:\n{ex.Message}", "Fehler",
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
              }

            }
            else goto default;

          }
          break;
        default:
          if (propInfo != null && e.NewValue != null)
          {
            // Dynamisch setzen
            propInfo.SetValue(this.auftrag, Convert.ChangeType(e.NewValue, propInfo.PropertyType));
          }
          break;
      }
      Save_Auftrag(this.auftrag, false);
      Neuladen_OLV(olv);

      //DONE: ZEILE MARKIEREN?
      olv.SelectedObject = e.RowObject;
      olv.EnsureModelVisible(e.RowObject);
      olv.Focus();

    }

    /// <summary>
    /// Ausgelöst durch DoppelClick
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void ObjectListViewAuftrag_CellEditStarting(object sender, CellEditEventArgs e)
    {
      ObjectListView olv = (ObjectListView)sender;
      Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)e.RowObject).AuftragID);
      
      if (e.Control is NumericUpDown num) num.Select(0, int.MaxValue);
      if (e.Control is ComboBox cb)
      {
        if (e.Value == null) return;
        if (cb.Created)
          cb.SelectedValue = e.Value;
        else
          this.BeginInvoke(new MethodInvoker(delegate {
            cb.SelectedValue = e.Value;
          }));
      }
    }

    #endregion

    /// <summary>
    /// Controls werden nach Benutzer deaktiviert.
    /// </summary>
    private void Enable_Controls()
    {
      switch (this.benutzer.Rolle)
      {
        case BenutzerRolle.Verwaltung:
          this.buttonNeuerAuftrag.Enabled = this.buttonSWS_Drucken.Enabled = false;
          

          GetUnvisibleColumns(this.objectListViewAuftrag);
          break;
        case BenutzerRolle.Fahrer:
          this.buttonNeuerAuftrag.Enabled = this.buttonSWS_Drucken.Enabled = false;
          

          GetUnvisibleColumns(this.objectListViewAuftrag);
          break;
        case BenutzerRolle.Admin:
          break;
        case BenutzerRolle.Waschstrasse:
          this.buttonNeuerAuftrag.Enabled = this.buttonSWS_Drucken.Enabled = false;
          

          GetUnvisibleColumns(this.objectListViewAuftrag);
          break;
        case BenutzerRolle.Master:
          break;
        case BenutzerRolle.Expedit:
          break;
        case BenutzerRolle.Frottee:
          this.buttonEtikettenDrucken.Visible = this.buttonNeuerAuftrag.Visible = this.buttonSWS_Drucken.Visible = false;
          this.buttonStats.Visible = false; // buttonReklamation einblenden wenn Frottee-Expedit auch Reklamation bearbeitet.
          foreach(TabPage tab in this.tabControlAuftragList.TabPages)
          {
            if (tab.Text == "Vorbereitet" || tab.Text == "Rampe") tabControlAuftragList.TabPages.Remove(tab);
          }

          break;
        case BenutzerRolle.Flach:
          this.buttonNeuerAuftrag.Enabled = this.buttonSWS_Drucken.Enabled = false;
          

          // WENN Rolle Frottee (Expedit Frottee) dann ButtonClick deaktiviert. Nur Expedit kann abschließen
          GetUnvisibleColumns(this.objectListViewAuftrag);
          break;
        default:
          break;
      }

    }

    /// <summary>
    /// Aufträge für TabPages werden von DB-VIEW geladen.
    /// </summary>
    /// <param name="liste">null wemm alle Listen neu geladen werden sollen</param>
    /// <returns>Task zu FormLoad</returns>
    private async Task GetAuftraegeAsync(ListenArt? liste)
    {
      if (this.benutzer.Rolle != BenutzerRolle.Frottee)
      {
        if (liste == null || liste == ListenArt.Auftragliste) listAuftragToday = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Gewaschen, datum: DateTime.Today.Date.AddDays(2));
        if (liste == null || liste == ListenArt.Geschäftliste) listAuftragGeschaeft = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Fertig, minStatusFilter: AuftragStatus.Abgeholt, typFilter: AuftragTyp.Geschäft);
        if (liste == null || liste == ListenArt.Vorbereitetliste) listVorbereitet = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Vorbereitet, minTypFilter: AuftragTyp.Standart);
        if (liste == null || liste == ListenArt.Sonderliste) listSonderAuftrag = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Fertig, minStatusFilter: AuftragStatus.Herrichten, minTypFilter: AuftragTyp.Inventur);
        if (liste == null || liste == ListenArt.Rampenliste) listRampe = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Abgeholt, typFilter: AuftragTyp.Standart);
      }
      else
      {
        if (liste == null || liste == ListenArt.Auftragliste) listAuftragToday = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Gewaschen, kategorie: ArtikelKategorie.Frottee, datum: DateTime.Today.Date.AddDays(2));
        if (liste == null || liste == ListenArt.Geschäftliste) listAuftragGeschaeft = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Fertig, minStatusFilter: AuftragStatus.Abgeholt, typFilter: AuftragTyp.Geschäft, kategorie: ArtikelKategorie.Frottee);
        if (liste == null || liste == ListenArt.Sonderliste) listSonderAuftrag = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Fertig, minStatusFilter: AuftragStatus.Herrichten, typFilter: AuftragTyp.Laufzettel, minTypFilter: AuftragTyp.Inventur, kategorie: ArtikelKategorie.Frottee);
      }

    }
    
    /// <summary>
    /// Zeigt Fenster zur Eingabe von Text.
    /// </summary>
    /// <param name="titel"></param>
    /// <param name="prompt"></param>
    /// <param name="defaultText"></param>
    /// <returns>Anzahl Saubere Container als string</returns>
    private string PromptForText(string titel, string prompt, string defaultText)
    {
      return Interaction.InputBox(prompt, titel, defaultText);
    }
    private void Save_Auftrag(Auftrag auftrag, bool show)
    {
      if (auftrag.Save()[0] == 1) if (show) meldung.Gespeichert();
        else if (show) meldung.Speicherfehler();
    }
    private void Aufgabe_erledigt(Auftrag _auftrag,Kunde _kunde, string name)
    {
      if (_kunde.AufgabeCount <= 0) _kunde.Aufgabe = null;
      else _kunde.AufgabeCount--;
      _auftrag.AufgabeErledigt = true;
      if (_auftrag.Save()[0] != 1) meldung.GetFehler(this, $"Der Auftrag konnte nicht gespeichert und die Aufgabe nicht als erledigt markiert werden. Melde das bitte deinem Vorgesetzten.");
      if (_kunde.Save() != 1) meldung.GetFehler(this, $"Der Kunde {name} konnte nicht gespeichert und die Aufgabe nicht entfernt werden. Melde das bitte deinem Vorgesetzten.");

    }

    /// <summary>
    /// Wird aufgerufen wenn ein Auftrag Fertig ist und so gespeichert werden soll.
    /// </summary>
    private void Auftrag_Fertig()
    {
      if (this.benutzer.Rolle == BenutzerRolle.Frottee) this.auftrag.Abteilungen |= AbteilungsStatus.FrotteeBeendet;
      else this.auftrag.Status = AuftragStatus.Fertig;
      this.auftrag.Save();

      if (this.auftrag.Typ == AuftragTyp.Inventur)
      {
        Program.InventurFertig(this.auftrag);
      }

      this.auftrag = null;
    }

    /// <summary>
    /// Beim Wechsel der Tabs wird ObjectListView neu geladen und Spalten ausgeblendet.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void TabControlAuftragList_SelectedIndexChanged(object sender, EventArgs e)
    {
      TabControl tabControl = sender as TabControl;
      if (!(tabControl.SelectedTab.Controls[0] is ObjectListView olv)) return;

      tabControl.SuspendLayout();
      olv.SuspendLayout();

      chartFehlmenge.Visible = false;
      groupBoxKndInfo.Visible = false;

      //GetUnvisibleColumns(olv);

      Neuladen_OLV(olv);

      olv.ResumeLayout();
      tabControl.ResumeLayout();
      this.UseWaitCursor = false;
    }

    /// <summary>
    /// Wenn Suche mehr als 1 Auftrag wird TabPage mit Ergebnis hinzugefügt. 
    /// </summary>
    /// <param name="liste"></param>
    /// <param name="listenArt"></param>
    private void AddTabPage(List<Auftrag> liste, ListenArt listenArt)
    {
      if (liste == null) return;
      UCAuftragListe ucl = new UCAuftragListe(this.benutzer, liste);
      TabPage tabPage = new TabPage();

      switch (listenArt)
      {
        case ListenArt.Auftragliste: // Aufträge HEUTE
          break;
        case ListenArt.Sonderliste: // Sonderaufträge
          break;
        case ListenArt.Geschäftliste: // Aufträge Geschäftskunden
          break;
        case ListenArt.Suchliste: // Aufträge gesucht
          string closeStr = " ×";  // Unicode X-Symbol
          tabPage.Text = "Suchergebnis" + closeStr;
          break;
        case ListenArt.Rampenliste: // Aufträge auf Rampe
          break;
        case ListenArt.Vorbereitetliste: // Vorbereitete Aufträge
          tabPage.Text = "Vorbereitet";
          break;
        default: //Alle Listen
          break;
      }

     
      // if (!tabPage.Text.Contains("Suche")) return;
      tabPage.Controls.Add(ucl);
      ucl.Dock = DockStyle.Fill;
      this.tabControlAuftragList.Controls.Add(tabPage);
    }
    
    /// <summary>
    /// MouseDown um Klick auf TabControl zu erkennen.
    /// Wenn Klick auf "x" wird die TabPage geschlossen. NUR BEI SUCHE MÖGLICH
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void TabControlAuftragList_MouseDown(object sender, MouseEventArgs e)
    {
      this.UseWaitCursor = true;
      if (e.Button == MouseButtons.Left)
      {
        for (int i = 0; i < tabControlAuftragList.TabCount; i++)
        {
          Rectangle r = tabControlAuftragList.GetTabRect(i);
          if (r.Contains(e.X, e.Y))
          {
            // X-Button-Bereich (rechts)
            Rectangle closeRect = new Rectangle(r.Right - 18, r.Top + 4, 14, 14);
            if (closeRect.Contains(e.X, e.Y))
            {
              if (tabControlAuftragList.TabPages[i].Text.Contains("Suche")) tabControlAuftragList.TabPages.RemoveAt(i);
              return;
            }
            tabControlAuftragList.SelectedIndex = i;
            this.UseWaitCursor = false;
            break;
          }
        }
      }
    }

    /// <summary>
    /// Malt Border der GroupBox für Anmerkungen. Farbe wechseln wenn ROT schlecht.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void GroupBoxKndInfo_Paint(object sender, PaintEventArgs e)
    {
      Funktionen.GetGroupBoxBoarder(groupBoxKndInfo, e);
    }

    /// <summary>
    /// Wenn Chart wird sichtbar wird die Position berechnet.
    /// Das TabControl wird um die Chart schmäler.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void ChartFehlmenge_VisibleChanged(object sender, EventArgs e)
    {
      UCFeedback fb = this.Controls.Find("feedback", false)[0] as UCFeedback;
      
      if (chartFehlmenge.Visible || groupBoxKndInfo.Visible)
      {
        this.tabControlAuftragList.Width = (int)(this.Width * 0.80);
        this.chartFehlmenge.Width = (int)(this.Width * 0.20) - 20;
        this.groupBoxKndInfo.Width = this.chartFehlmenge.Width - 10;

        int chartHeight = (int)(this.tabControlAuftragList.Height * 0.75);
        int gbHeight = (int)(this.tabControlAuftragList.Height * 0.25);

        chartFehlmenge.Location = new Point(this.tabControlAuftragList.Right + 10, this.tabControlAuftragList.Top);
        chartFehlmenge.Size = new Size(groupBoxKndInfo.Width, chartHeight);
        groupBoxKndInfo.Height = gbHeight;
        groupBoxKndInfo.Location = new Point(this.tabControlAuftragList.Right + 10, this.tabControlAuftragList.Bottom - gbHeight);

        fb.Visible = false;
      }
      else
      {
        this.tabControlAuftragList.Width = this.Width - 25;
        fb.Visible = true;
      }
    }

    /// <summary>
    /// Wenn die GroupBox für Aufgabe und Anmerkung sichtbar wird wird die Position berechnet.
    /// Das TabControl wird um die GroupBox schmäler.
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void GroupBoxKndInfo_VisibleChanged(object sender, EventArgs e)
    {
      if (groupBoxKndInfo.Visible)
      {
        this.tabControlAuftragList.Width = (int)(this.Width * 0.80);
        this.groupBoxKndInfo.Width = (int)(this.Width * 0.20) - 20;

        int gbHeight = (int)(this.tabControlAuftragList.Height * 0.25);

        groupBoxKndInfo.Height = gbHeight;
        groupBoxKndInfo.Location = new Point(this.tabControlAuftragList.Right + 10, this.tabControlAuftragList.Bottom - gbHeight);

      }
      else
      {
        this.tabControlAuftragList.Width = this.Width - 25;
      }
    }
    private async void FormExpedit_HelpButtonClicked(object sender, System.ComponentModel.CancelEventArgs e)
    {
      this.benutzer.OnboardingStatus = this.benutzer.ClearOnboardingFlag(onBoardingArt); // OnBoarding zurücksetzen
      await this.benutzer.UpdateOnBoardingAsync(); // Update OnBoardingStatus
      ZeigeOnboarding();
    }
    private async void ZeigeOnboarding()
    {
      if (this.benutzer.IstGesehen(onBoardingArt)) return;  // Bereits fertig

      if (Program.ShowOnBoarding(this.benutzer.Rolle.ToString(), onBoardingArt) == DialogResult.OK)
      {
        // Nächster Schritt → Flag setzen
        this.benutzer.OnboardingStatus = this.benutzer.SetOnboardingFlag(onBoardingArt);
        await this.benutzer.UpdateOnBoardingAsync();  // Deine Update-Methode
        //this.Close();  // Onboarding beendet
      }
    }

    private void chartFehlmenge_DoubleClick(object sender, EventArgs e)
    {
      Chart chart = (Chart)sender;
      Kunde _knd = chart.Tag as Kunde;
      List<KundeArtikel> kndartListe = KundeArtikel.GetList(_knd.KundeID.ToString());

      Auftrag _auftrag = new Auftrag()
      {
        KundeID = (int)_knd.KundeID,
        Typ = AuftragTyp.IST_Erhoehung,
        Erstellt = DateTime.Now,
        ErstelltVon = (int)this.benutzer.BenutzerID,
        Status = AuftragStatus.Herrichten,

      };
      

      FormAuftragDetail detail = new FormAuftragDetail(_auftrag, this.benutzer, kndartListe);
      detail.Show();
      //TODO: Wie soll es weiter gehen? 
    }

    private void objectListViewAuftrag_ColumnClick(object sender, ColumnClickEventArgs e)
    {
      var olv = (ObjectListView)sender;
      var olvStatus = olv.AllColumns.Cast<OLVColumn>().FirstOrDefault(c => c.Text == "Status");
      var olvLiefertag = olv.AllColumns.Cast<OLVColumn>().FirstOrDefault(c => c.Text == "Liefertag");

      // Wenn auf Status geklickt: nach Status gruppieren
      if (e.Column == olvStatus.Index)
      {
        // Gruppierung nach Status ändern
        olv.AlwaysGroupByColumn = olvStatus;           // Fixierung entfernen
        olv.AlwaysGroupBySortOrder = SortOrder.None;            // Nach Status gruppieren

        // Innerhalb der Gruppen nach Liefertag ASC sortieren
        olv.SecondarySortColumn = olvLiefertag;
        olv.SecondarySortOrder = SortOrder.Ascending;

        // Sorting erzwingen
        olv.BeginUpdate();
        olv.BuildGroups();
        olv.Sort();
        olv.EndUpdate();
      }
      else
      {
        // Für andere Spalten: normale Sortierung, aber Liefertag als Tie-Breaker
        olv.SecondarySortColumn = olvLiefertag;
        olv.SecondarySortOrder = SortOrder.Ascending;
        olv.Sort(e.Column);
      }
    }

  }
}
//DONE: Lösung zum Löschen von Aufträgen überlegen. (Kevin fragen)
//CHANGES: Trello-Karte nach Liefertagänderung kann von Admin oder Verwaltung erstellt werden.
//CHANGES: Im Tab Vorbereitet wird beim Ändern der sauberen Containeranzahl gefragt ob die Etiketten neu gedruckt werden sollen.
//CHANGES: Im Tab Rampe wird bei DoppelClick der Auftrag als gewaschen markiert und im Tab Aufträge heute sichtbar. 
//CHANGES: Wenn ein anderer Fahrer ausgewählt wird, wird auch die Priority laut dem Fahrer geändert.
//CHANGES: NumericUpDown markiert automatisch den Inhalt. Erleichtert die Eingabe.
//CHANGES: Wenn Expedit NeuerAuftrag aufruft wird gefragt welcher Auftrag gewünscht ist. Geschäftkunde = Geschäft (Notwendig bis ausschließlich Fahrer die Standardaufträge erstellen)