using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using Avalonia.Controls;
using Avalonia.Input;
using Avalonia.Interactivity;
using Avalonia.Platform.Storage;

namespace spplus;

public partial class MainWindow : Window
{
    public static MainWindow Instance { get; set; }
    public static string ApplicationVersion = "v1.2.24";

    private sealed class ResultEntry
    {
        public Student Student { get; }
        public int Semester { get; }
        public string CourseName { get; }

        public ResultEntry(Student student, int semester, string? courseName)
        {
            Student = student;
            Semester = semester;
            CourseName = courseName ?? string.Empty;
        }

        public override string ToString()
        {
            return $"{Student.Name} ({Student.ID}) - {Semester}. Semester: {CourseName}";
        }
    }

    public MainWindow()
    {
        InitializeComponent();
        Settings.ImportInitial();
        Instance = this;
        RefreshCoursesList();
        try
        {
            NudSportMaxPerSemester1.Value = Settings.Instance.NumCoursesPerSemester[0];
            NudSportMaxPerSemester2.Value = Settings.Instance.NumCoursesPerSemester[1];
            NudSportMaxPerSemester3.Value = Settings.Instance.NumCoursesPerSemester[2];
            NudSportMaxPerSemester4.Value = Settings.Instance.NumCoursesPerSemester[3];
        } catch {}
    }

    private void RegenerateContextMenu()
    {
        MnuChange.Items.Clear();
        foreach (var sport in Settings.Instance.Sports)
        {
            var item = new MenuItem { Header = sport.Name };
            item.Click += (_, _) => ChangeStudentCourse(sport);
            MnuChange.Items.Add(item);
        }
    }

    private async void ChangeStudentCourse(Sport targetSport)
    {
        if (LbResult.SelectedItem is not ResultEntry selectedEntry)
            return;

        try
        {
            if (await ApplyStudentCourseChange(selectedEntry.Student, selectedEntry.Semester, targetSport))
            {
                CourseCrafter.ReloadResult();
                RefreshResultView();
                RegenerateContextMenu();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
        }
    }

    private async Task<bool> ApplyStudentCourseChange(Student student, int semester, Sport targetSport)
    {
        if (semester < 1 || semester > 4)
            return false;

        var semesterCourses = CourseCrafter.GeneratedCourses
            .Where(course => course.Semester == semester)
            .ToList();

        var currentCourses = semesterCourses
            .Where(course => course.Instance.Students.Contains(student.ID))
            .ToList();

        string? oldSportName = currentCourses
            .Select(course => course.Instance.Sport.Name)
            .FirstOrDefault();

        var existingTargetCourses = semesterCourses
            .Where(course => course.Instance.Sport.Name == targetSport.Name)
            .ToList();

        CourseCrafter.CourseInstance? targetCourse = existingTargetCourses
            .Where(course => !course.Instance.Students.Contains(student.ID) &&
                             course.Instance.Students.Count < course.Instance.Sport.MaxStudents)
            .OrderBy(course => course.Instance.Students.Count)
            .Select(course => course.Instance)
            .FirstOrDefault();

        if (targetCourse == null && existingTargetCourses.Any())
        {
            targetCourse = existingTargetCourses
                .OrderBy(course => course.Instance.Students.Count)
                .Select(course => course.Instance)
                .FirstOrDefault();
        }

        bool changed = false;

        foreach (var course in currentCourses)
        {
            if (targetCourse != null && ReferenceEquals(course.Instance, targetCourse))
                continue;

            if (course.Instance.Students.Remove(student.ID))
                changed = true;
        }

        int removedEmptyCourses = CourseCrafter.GeneratedCourses.RemoveAll(course =>
            course.Semester == semester &&
            course.Instance.Students.Count == 0 &&
            !ReferenceEquals(course.Instance, targetCourse));
        if (removedEmptyCourses > 0)
            changed = true;

        if (targetCourse == null)
        {
            var newCourse = new CourseCrafter.CourseInstance
            {
                Sport = targetSport,
                Students = new List<string> { student.ID }
            };

            CourseCrafter.GeneratedCourses.Add((semester, newCourse));
            changed = true;
        }
        else if (!targetCourse.Students.Contains(student.ID))
        {
            targetCourse.Students.Add(student.ID);
            changed = true;
        }

        if (changed && !string.IsNullOrEmpty(oldSportName) &&
            IsRebalanceNeededForSportSemester(oldSportName, semester))
        {
            var result = await MessageBox.Show(this,
                $"Der Kursplan für {oldSportName} im {semester}. Semester ist nach der Änderung unausgeglichen. Soll die alte Sportart umverteilt werden?",
                "Umverteilung der alten Sportart", MessageBoxButton.YesNo);

            if (result == MessageBoxResult.Yes)
                BalanceSportSemester(oldSportName, semester);
        }

        return changed;
    }

    private bool IsRebalanceNeededForSportSemester(string sportName, int semester)
    {
        var courses = CourseCrafter.GeneratedCourses
            .Where(course => course.Semester == semester && course.Instance.Sport.Name == sportName)
            .ToList();

        if (courses.Count <= 1)
            return false;

        var ordered = courses
            .OrderBy(course => course.Instance.Students.Count)
            .ToList();

        int minCount = ordered.First().Instance.Students.Count;
        int maxCount = ordered.Last().Instance.Students.Count;
        if (maxCount - minCount <= 1)
            return false;

        if (ordered.Last().Instance.Students.Count - 1 < GetEffectiveMinStudents(ordered.Last().Instance.Sport, semester))
            return false;

        if (ordered.First().Instance.Students.Count >= ordered.First().Instance.Sport.MaxStudents)
            return false;

        return true;
    }

    private void BalanceSportSemester(string sportName, int semester)
    {
        bool changed;
        do
        {
            changed = false;

            var courses = CourseCrafter.GeneratedCourses
                .Where(course => course.Semester == semester && course.Instance.Sport.Name == sportName)
                .OrderBy(course => course.Instance.Students.Count)
                .ToList();

            if (courses.Count <= 1)
                break;

            var target = courses.First();
            var source = courses.Last();

            if (source.Instance.Students.Count <= target.Instance.Students.Count + 1)
                break;

            if (source.Instance.Students.Count - 1 < GetEffectiveMinStudents(source.Instance.Sport, semester))
                break;

            if (target.Instance.Students.Count >= target.Instance.Sport.MaxStudents)
                break;

            var studentId = source.Instance.Students[^1];
            source.Instance.Students.RemoveAt(source.Instance.Students.Count - 1);
            target.Instance.Students.Add(studentId);
            changed = true;
        } while (changed);
    }

    private int GetEffectiveMinStudents(Sport sport, int semester)
    {
        int reduction = (semester >= 3) ? 2 : 0;
        return Math.Max(1, sport.MinStudents - reduction);
    }

    private async void MnuExpSettings_OnClick(object? sender, RoutedEventArgs e)
    {
        await ExportConfigurationAsync();
    }

    private void MnuExit_OnClick(object? sender, RoutedEventArgs e)
    {
        Environment.Exit(0);
    }

    private void MnuHelp_OnClick(object? sender, RoutedEventArgs e)
    {
        try
        {
            Process.Start(new ProcessStartInfo
            {
                FileName = "https://git.mypapercloud.de/fierke/spplus/wiki",
                UseShellExecute = true 
            });
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Fehler beim Öffnen des Links: {ex.Message}");
        }
    }

    private void MnuGit_OnClick(object? sender, RoutedEventArgs e)
    {
        try
        {
            Process.Start(new ProcessStartInfo
            {
                FileName = "https://git.mypapercloud.de/fierke/spplus",
                UseShellExecute = true 
            });
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Fehler beim Öffnen des Links: {ex.Message}");
        }
    }

    private void MnuAbout_OnClick(object? sender, RoutedEventArgs e)
    {
        Window w = new();
        w.WindowState = WindowState.Normal;
        w.WindowStartupLocation = WindowStartupLocation.CenterScreen;
        w.Width = 300;
        w.Height = 120;
        Grid g = new();
        TextBlock tb = new()
        {
            Text = $"spplus {MainWindow.ApplicationVersion}\n(c)2026 MyPapertown, Elias Fierke"
        };
        g.Children.Add(tb);
        w.Content = g;
        w.Show();
    }

    private async void BtnImport_OnClick(object? sender, RoutedEventArgs e)
    {
        var topLevel = GetTopLevel(this);
        var file = await topLevel!.StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
        {
            Title = "CSV-Datei auswählen",
            AllowMultiple = false,
            FileTypeFilter = new[]
            {
                new FilePickerFileType(".csv-Datei")
                {
                    Patterns = new[] { "*.csv" }
                }
            }
        });

        if (file == null) return;
        if (file.Count == 0) return;

        var imported_students = import.ImportStudentsFromFile(file[0].Path.LocalPath.ToString());
        foreach (var s in imported_students)
        {
            Settings.Instance.Students.Add(s);
        }
        RefreshImportedStudentList();

    }

    private void RefreshImportedStudentList()
    {
        LbStudentsImported.Items.Clear();
        int count_selected = 0;
        foreach (var s in Settings.Instance.Students)
        {
            LbStudentsImported.Items.Add(s);
            count_selected += s.SelectedCourseNames.Count;
        }
        LblStudentAmount.Content =  Settings.Instance.Students.Count.ToString();
        LblSelectedAmount.Content =  count_selected.ToString();
        
        List<(Sport, List<string>)> initial_sportlist = new();
        foreach (var sp in Settings.Instance.Sports)
        {
            initial_sportlist.Add((sp, new()));
        }
        foreach (Student s in Settings.Instance.Students)
        {
            foreach (var sp in s.SelectedCourseNames)
            {
                foreach (var item in initial_sportlist)
                {
                    if (item.Item1.AlternativeNames.Contains(sp))
                    {
                        item.Item2.Add(s.ID);
                        break;
                    }
                }
            }
        }

        LblNumVoted.Content = "";
        foreach (var s in initial_sportlist)
        {
            LblNumVoted.Content += $"{s.Item1.Name}: {s.Item2.Count}\n";
        }
        
    }

    private void BtnCraftCourses_OnClick(object? sender, RoutedEventArgs e)
    {
        CourseCrafter.Craft();
        RefreshResultView();
        TclMainView.SelectedIndex = 2;
        //TbiResults.Focus();
    }

    private void LbResult_OnPointerPressed(object? sender, PointerPressedEventArgs e)
    {
        if (!e.GetCurrentPoint(LbResult).Properties.IsRightButtonPressed)
            return;

        if (e.Source is Control control && control.DataContext is ResultEntry entry)
        {
            LbResult.SelectedItem = entry;
        }
        else
        {
            LbResult.SelectedItem = null;
        }
    }

    private void RefreshResultView()
    {
        LbResult.Items.Clear();
        foreach (Student s in Settings.Instance.Students)
        {
            try
            {
                for(int i = 0; i<s.Result.Length;i++)
                {
                    LbResult.Items.Add(new ResultEntry(s, i + 1, s.Result[i]));
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.StackTrace);
            }
        }
        
        TbResultStatistics.Text = CourseCrafter.GenerateStatistics();
    }

    private void LbStudentsImported_OnSelectionChanged(object? sender, SelectionChangedEventArgs e)
    {
        Prepare();
        var stud = (Student)LbStudentsImported.SelectedItem;
        if (stud == null)
        {
            TbStudentName.Text = string.Empty;
            TbStudentID.Text = string.Empty;
            SetEmpty();
            return;
        };

        try
        {
            TbStudentName.Text = stud.Name;
            TbStudentID.Text = stud.ID;
            LblSport1.Content = stud.SelectedCourseNames[0];
            LblSport2.Content = stud.SelectedCourseNames[1];
            LblSport3.Content = stud.SelectedCourseNames[2];
            LblSport4.Content = stud.SelectedCourseNames[3];
        }
        catch
        {
            SetEmpty();
        }

        return;
        
        void SetEmpty()
        {
            if(LblSport1.Content == "null") LblSport1.Content = "ungewählt";
            if(LblSport2.Content == "null") LblSport2.Content = "ungewählt";
            if(LblSport3.Content == "null") LblSport3.Content = "ungewählt";
            if(LblSport4.Content == "null") LblSport4.Content = "ungewählt";
        }

        void Prepare()
        {
            LblSport1.Content = "null";
            LblSport2.Content = "null";
            LblSport3.Content = "null";
            LblSport4.Content = "null";
        }
        
    }

    private void TbStudentName_OnTextChanged(object? sender, TextChangedEventArgs e)
    {
        try
        {
            ((Student)LbStudentsImported.SelectedItem).Name = TbStudentName.Text;
        }
        catch
        {
            
        }
    }
    private void TbStudentID_OnTextChanged(object? sender, TextChangedEventArgs e)
    {
        try
        {
            ((Student)LbStudentsImported.SelectedItem).ID = TbStudentID.Text;
        }
        catch
        {
            
        }
    }

    private void BtnImportDefaultCourses_OnClick(object? sender, RoutedEventArgs e)
    {
        Settings.ImportInitial();
        RefreshCoursesList();
    }

    private void RefreshCoursesList()
    {
        LbSportCourses.Items.Clear();
        foreach (var sp in Settings.Instance.Sports)
        {
            LbSportCourses.Items.Add(sp);
        }
        RegenerateContextMenu();
    }


    private void LbSportCourses_OnSelectionChanged(object? sender, SelectionChangedEventArgs e)
    {
        if (LbSportCourses.SelectedItem != null)
        {
            if (LbSportCourses.SelectedItem is Sport item)
            {
                LblSportID.Content = item.ID;
                TbSportName.Text = item.Name;
                NudSportMaxStudents.Value = item.MaxStudents;
                NudSportMinStudents.Value = item.MinStudents;
                NudAmountCoursesSem1.Value = item.Semester[0];
                NudAmountCoursesSem2.Value = item.Semester[1];
                NudAmountCoursesSem3.Value = item.Semester[2];
                NudAmountCoursesSem4.Value = item.Semester[3];
                // LbAlternativeCourses.Items.Clear();
                // foreach (var alternative in item.AlternativeCourses)
                // {
                //     LbAlternativeCourses.Items.Add(Settings.GetSportNameFromID(alternative));
                // }
                LbAlternativeNames.Items.Clear();
                foreach (var alternative in item.AlternativeNames)
                {
                    LbAlternativeNames.Items.Add(alternative);
                }
            }
        }
    }

    private void TbSportName_OnTextChanged(object? sender, TextChangedEventArgs e)
    {
        try
        {
            ((Sport)LbSportCourses.SelectedItem).Name = TbSportName.Text;
            RegenerateContextMenu();
        } catch {}
    }

    private void NudSportMaxStudents_OnValueChanged(object? sender, NumericUpDownValueChangedEventArgs e)
    {
        try
        {
            ((Sport)LbSportCourses.SelectedItem).MaxStudents = Convert.ToInt32(NudSportMaxStudents.Value);
        } catch {}
    }

    private void NudSportMinStudents_OnValueChanged(object? sender, NumericUpDownValueChangedEventArgs e)
    {
        try
        {
            ((Sport)LbSportCourses.SelectedItem).MinStudents = Convert.ToInt32(NudSportMinStudents.Value);
        } catch {}
    }

    private void NudAmountCoursesSem1_OnValueChanged(object? sender, NumericUpDownValueChangedEventArgs e)
    {
        try
        {
            ((Sport)LbSportCourses.SelectedItem).Semester[0] = Convert.ToInt32(NudAmountCoursesSem1.Value);
        } catch {}
    }

    private void NudAmountCoursesSem2_OnValueChanged(object? sender, NumericUpDownValueChangedEventArgs e)
    {
        try
        {
            ((Sport)LbSportCourses.SelectedItem).Semester[1] = Convert.ToInt32(NudAmountCoursesSem2.Value);
        } catch {}
    }

    private void NudAmountCoursesSem3_OnValueChanged(object? sender, NumericUpDownValueChangedEventArgs e)
    {
        try
        {
            ((Sport)LbSportCourses.SelectedItem).Semester[2] = Convert.ToInt32(NudAmountCoursesSem3.Value);
        } catch {}
    }

    private void NudAmountCoursesSem4_OnValueChanged(object? sender, NumericUpDownValueChangedEventArgs e)
    {
        try
        {
            ((Sport)LbSportCourses.SelectedItem).Semester[3] = Convert.ToInt32(NudAmountCoursesSem4.Value);
        } catch {}
    }

    private void BtnAlternativeCourseAdd_OnClick(object? sender, RoutedEventArgs e)
    {
        try
        {
            //((Sport)LbSportCourses.SelectedItem).AlternativeNames.Add(TbSportAlternativeName.Text);
            //TbSportAlternativeCourse.Text = "";
        } catch {}
    }

    private void BtnAlternativeNameAdd_OnClick(object? sender, RoutedEventArgs e)
    {
        try
        {
            ((Sport)LbSportCourses.SelectedItem).AlternativeNames.Add(TbSportAlternativeName.Text);
            LbAlternativeNames.Items.Add(TbSportAlternativeName.Text);
            TbSportAlternativeName.Text = "";
            
            int curr_selected = LbSportCourses.SelectedIndex; 
            RefreshCoursesList();
            LbSportCourses.SelectedIndex = curr_selected;
        } catch {}
    }

    private void BtnAlternativeNameRemove_OnClick(object? sender, RoutedEventArgs e)
    {
        //try
        //{
            LbAlternativeNames.Items.Remove(LbAlternativeNames.SelectedItem);
            ((Sport)LbSportCourses.SelectedItem).AlternativeNames.Clear();
            foreach (string s in LbAlternativeNames.Items)
            {
                ((Sport)LbSportCourses.SelectedItem).AlternativeNames.Add(s);
            }

            int curr_selected = LbSportCourses.SelectedIndex; 
            RefreshCoursesList();
            LbSportCourses.SelectedIndex = curr_selected;
            //} catch (Exception ex) {}
    }

    private async void BtnClearCourseList_OnClick(object? sender, RoutedEventArgs e)
    {
        var result = await MessageBox.Show(this,
            "Möchten Sie wirklich alle Kurse löschen?\n Dies kann nicht rückgängig gemacht werden.",
            "Wirklich fortfahren?", MessageBoxButton.YesNo);
        if (result == MessageBoxResult.Yes)
        {
            Settings.Instance.Sports.Clear();
            RefreshCoursesList();    
        }
        
    }

    private void BtnDeleteSinleCourse_OnClick(object? sender, RoutedEventArgs e)
    {
        try
        {
            Settings.Instance.Sports.Remove(LbSportCourses.SelectedItem as Sport);
            RefreshCoursesList();
        } catch (Exception ex){}
    }

    private async void BtnExportCoursePDF_OnClick(object? sender, RoutedEventArgs e)
    {
        var topLevel = GetTopLevel(this);
        var file = await topLevel!.StorageProvider.SaveFilePickerAsync(new FilePickerSaveOptions
        {
            Title = "PDF-Datei speichern",
            SuggestedFileName = "spplus_kurse.pdf",
            SuggestedFileType = new FilePickerFileType(".pdf-Datei")
            {
                Patterns = new[] { "*.pdf" }
            }
        });

        if (file == null) return;

        PdfExportUtility.ExportGeneratedCourses(file.Path.LocalPath);
    }

    private void NudSportMaxPerSemester1_OnValueChanged(object? sender, NumericUpDownValueChangedEventArgs e)
    {
        try
        {
            Settings.Instance.NumCoursesPerSemester[0] = Convert.ToInt32(NudSportMaxPerSemester1.Value);
        } catch {}
    }
    
    private void NudSportMaxPerSemester2_OnValueChanged(object? sender, NumericUpDownValueChangedEventArgs e)
    {
        try
        {
            Settings.Instance.NumCoursesPerSemester[1] = Convert.ToInt32(NudSportMaxPerSemester2.Value);
        } catch {}
    }
    
    private void NudSportMaxPerSemester3_OnValueChanged(object? sender, NumericUpDownValueChangedEventArgs e)
    {
        try
        {
            Settings.Instance.NumCoursesPerSemester[2] = Convert.ToInt32(NudSportMaxPerSemester3.Value);
        } catch {}
    }
    
    private void NudSportMaxPerSemester4_OnValueChanged(object? sender, NumericUpDownValueChangedEventArgs e)
    {
        try
        {
            Settings.Instance.NumCoursesPerSemester[3] = Convert.ToInt32(NudSportMaxPerSemester4.Value);
        } catch {}
    }

    private async void BtnExportCourseCSV_OnClick(object? sender, RoutedEventArgs e)
    {
        var topLevel = GetTopLevel(this);
        var file = await topLevel!.StorageProvider.SaveFilePickerAsync(new FilePickerSaveOptions
        {
            Title = "CSV-Datei speichern",
            SuggestedFileName = "spplus_ergebnisse.json",
            SuggestedFileType = new FilePickerFileType(".json-Datei")
            {
                Patterns = new[] { "*.json" }
            }
            
        });

        if (file == null) return;

        ExportUtility.ExportResultsToJson(file.Path.LocalPath);

    }

    private async void MnuImpResult_OnClick(object? sender, RoutedEventArgs e)
    {
        var topLevel = GetTopLevel(this);
        var file = await topLevel!.StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
        {
            Title = "Ergebnis-CSV laden",
            AllowMultiple = false,
            FileTypeFilter = new[]
            {
                new FilePickerFileType(".json-Datei")
                {
                    Patterns = new[] { "*.json" }
                }
            }
        });

        if (file == null || file.Count == 0) return;

        var imported = import.ImportResultFromJson(file[0].Path.LocalPath.ToString());
        if (imported != null && imported.Count > 0)
        {
            CourseCrafter.GeneratedCourses = imported
                .OrderBy(c => c.Semester)
                .ThenBy(c => c.Instance.Sport.Name)
                .ToList();
            CourseCrafter.ReloadResult();
            RefreshResultView();
        }
    }

    private async System.Threading.Tasks.Task ExportConfigurationAsync()
    {
        var topLevel = GetTopLevel(this);
        var file = await topLevel!.StorageProvider.SaveFilePickerAsync(new FilePickerSaveOptions
        {
            Title = "Konfiguration speichern",
            SuggestedFileName = "spplus_konfiguration.json",
            SuggestedFileType = new FilePickerFileType(".json-Datei")
            {
                Patterns = new[] { "*.json" }
            }
        });

        if (file == null) return;

        ExportUtility.ExportConfigurationToJson(file.Path.LocalPath);
    }
}