using Microsoft.EntityFrameworkCore;
using timetracker.Shared;

namespace timetracker.Data;

public class TimetrackerService(IDbContextFactory<TimetrackerDbContext> factory) : ITimetrackerService
{
    public async Task<List<WorkDay>> GetWeekAsync(int userId, DateOnly monday)
    {
        await using var db = await factory.CreateDbContextAsync();
        return await db.WorkDays
            .Include(w => w.Breaks)
            .Where(w => w.UserId == userId && w.Date >= monday && w.Date < monday.AddDays(7))
            .OrderBy(w => w.Date)
            .ToListAsync();
    }

    public async Task UpsertWorkDayAsync(WorkDay workDay)
    {
        await using var db = await factory.CreateDbContextAsync();
        var existing = await db.WorkDays
            .Include(w => w.Breaks)
            .FirstOrDefaultAsync(w => w.UserId == workDay.UserId && w.Date == workDay.Date);

        if (existing == null)
        {
            workDay.Id = 0;
            foreach (var b in workDay.Breaks) b.Id = 0;
            db.WorkDays.Add(workDay);
        }
        else
        {
            existing.StartTime = workDay.StartTime;
            existing.EndTime = workDay.EndTime;
            db.BreakEntries.RemoveRange(existing.Breaks);
            existing.Breaks.Clear();
            foreach (var b in workDay.Breaks)
                existing.Breaks.Add(new BreakEntry
                {
                    WorkDayId = existing.Id,
                    StartTime = b.StartTime,
                    EndTime = b.EndTime
                });
        }

        await db.SaveChangesAsync();
    }

    public async Task<AppSettings> GetSettingsAsync(int userId)
    {
        await using var db = await factory.CreateDbContextAsync();
        return await db.AppSettings.FirstOrDefaultAsync(s => s.UserId == userId)
            ?? new AppSettings { UserId = userId };
    }

    public async Task SaveSettingsAsync(AppSettings settings)
    {
        await using var db = await factory.CreateDbContextAsync();
        var existing = await db.AppSettings.FirstOrDefaultAsync(s => s.UserId == settings.UserId);
        if (existing == null)
            db.AppSettings.Add(settings);
        else
        {
            existing.DailyTargetHours = settings.DailyTargetHours;
            existing.MinimumBreakMinutes = settings.MinimumBreakMinutes;
            existing.VacationDaysPerYear = settings.VacationDaysPerYear;
            existing.WorkMonday = settings.WorkMonday;
            existing.WorkTuesday = settings.WorkTuesday;
            existing.WorkWednesday = settings.WorkWednesday;
            existing.WorkThursday = settings.WorkThursday;
            existing.WorkFriday = settings.WorkFriday;
            existing.WorkSaturday = settings.WorkSaturday;
            existing.WorkSunday = settings.WorkSunday;
        }
        await db.SaveChangesAsync();
    }

    // ── Urlaub ────────────────────────────────────────────────────────────
    public async Task<List<VacationDay>> GetVacationDaysAsync(int userId, int year)
    {
        await using var db = await factory.CreateDbContextAsync();
        return await db.VacationDays
            .Where(v => v.UserId == userId && v.Date.Year == year)
            .OrderBy(v => v.Date)
            .ToListAsync();
    }

    public async Task AddVacationDayAsync(VacationDay vacationDay)
    {
        await using var db = await factory.CreateDbContextAsync();
        var exists = await db.VacationDays.AnyAsync(v => v.UserId == vacationDay.UserId && v.Date == vacationDay.Date);
        if (!exists)
        {
            vacationDay.Id = 0;
            db.VacationDays.Add(vacationDay);
            await db.SaveChangesAsync();
        }
    }

    public async Task RemoveVacationDayAsync(int userId, int id)
    {
        await using var db = await factory.CreateDbContextAsync();
        var v = await db.VacationDays.FirstOrDefaultAsync(v => v.Id == id && v.UserId == userId);
        if (v != null)
        {
            db.VacationDays.Remove(v);
            await db.SaveChangesAsync();
        }
    }

    // ── Gleitzeitkonto ───────────────────────────────────────────────────
    public async Task<TimeSpan> GetTotalOvertimeAsync(int userId, AppSettings settings)
    {
        await using var db = await factory.CreateDbContextAsync();

        // 1. Finde das Startdatum für die Berechnung
        var firstDay = await db.WorkDays
            .Where(w => w.UserId == userId)
            .OrderBy(w => w.Date)
            .Select(w => (DateOnly?)w.Date)
            .FirstOrDefaultAsync();

        if (firstDay == null && !settings.FlexTimeStartDate.HasValue)
            return TimeSpan.FromHours(settings.FlexTimeStartingBalanceHours);

        var startDate = settings.FlexTimeStartDate ?? firstDay!.Value;
        var endDate = DateOnly.FromDateTime(DateTime.Today);

        if (startDate > endDate)
            return TimeSpan.FromHours(settings.FlexTimeStartingBalanceHours);

        // 2. Lade alle erfassten Arbeitstage in diesem Zeitraum
        var workDays = await db.WorkDays
            .Include(w => w.Breaks)
            .Where(w => w.UserId == userId && w.Date >= startDate && w.Date <= endDate)
            .ToDictionaryAsync(w => w.Date);

        // 3. Lade alle Feiertage in diesem Zeitraum
        var holidaysList = await db.PublicHolidays
            .Where(h => h.Date >= startDate && h.Date <= endDate)
            .ToListAsync();

        var state = settings.GermanState;
        var holidaySet = holidaysList
            .Where(h => string.IsNullOrEmpty(h.Counties) || (!string.IsNullOrEmpty(state) && h.Counties.Split(',').Contains(state)))
            .Select(h => h.Date)
            .ToHashSet();

        // 4. Lade alle Urlaubstage in diesem Zeitraum
        var vacationSet = await db.VacationDays
            .Where(v => v.UserId == userId && v.Date >= startDate && v.Date <= endDate)
            .Select(v => v.Date)
            .ToHashSetAsync();

        double totalOvertimeHours = settings.FlexTimeStartingBalanceHours;

        for (var date = startDate; date <= endDate; date = date.AddDays(1))
        {
            bool isWorkDay = settings.IsWorkDay(date.DayOfWeek);
            bool isHoliday = holidaySet.Contains(date);
            bool isVacation = vacationSet.Contains(date);

            // Sollzeit gilt nur an regulären Arbeitstagen, die weder Feiertag noch Urlaub sind
            double target = (isWorkDay && !isHoliday && !isVacation) ? settings.DailyTargetHours : 0.0;
            double actual = 0.0;

            if (workDays.TryGetValue(date, out var wd) && wd.StartTime != null && wd.EndTime != null)
            {
                var gross = wd.EndTime.Value.ToTimeSpan() - wd.StartTime.Value.ToTimeSpan();
                if (gross > TimeSpan.Zero)
                {
                    var breakTotal = wd.Breaks
                        .Where(b => b.StartTime.HasValue && b.EndTime.HasValue && b.EndTime > b.StartTime)
                        .Aggregate(TimeSpan.Zero, (s, b) =>
                            s + (b.EndTime!.Value.ToTimeSpan() - b.StartTime!.Value.ToTimeSpan()));
                    var minMinutes = gross.TotalHours >= 9.0 ? 45 : 30;
                    var minBreak = TimeSpan.FromMinutes(Math.Max(minMinutes, settings.MinimumBreakMinutes));
                    var finalBreak = breakTotal > minBreak ? breakTotal : minBreak;
                    actual = (gross - finalBreak).TotalHours;
                    if (actual < 0) actual = 0.0;
                }
            }

            totalOvertimeHours += (actual - target);
        }

        return TimeSpan.FromHours(totalOvertimeHours);
    }

    // ── Monatsübersicht ───────────────────────────────────────────────────
    public async Task<List<WorkDay>> GetMonthAsync(int userId, int year, int month)
    {
        await using var db = await factory.CreateDbContextAsync();
        var from = new DateOnly(year, month, 1);
        var to = from.AddMonths(1);
        return await db.WorkDays
            .Include(w => w.Breaks)
            .Where(w => w.UserId == userId && w.Date >= from && w.Date < to)
            .OrderBy(w => w.Date)
            .ToListAsync();
    }

    // ── Dashboard ─────────────────────────────────────────────────────────
    public async Task<DashboardStatsVm> GetDashboardStatsAsync(int userId, int year, int month)
    {
        await using var db = await factory.CreateDbContextAsync();
        var startDate = new DateOnly(year, month, 1);
        var endDate = startDate.AddMonths(1).AddDays(-1);

        var workDays = await db.WorkDays
            .Include(w => w.Breaks)
            .Where(w => w.UserId == userId && w.Date >= startDate && w.Date <= endDate)
            .ToListAsync();

        var stats = new DashboardStatsVm();

        if (workDays.Any(w => w.StartTime.HasValue))
        {
            var earliest = workDays.Where(w => w.StartTime.HasValue).Min(w => w.StartTime!.Value);
            stats.EarliestStart = earliest.ToTimeSpan();
        }

        if (workDays.Any(w => w.EndTime.HasValue))
        {
            var latest = workDays.Where(w => w.EndTime.HasValue).Max(w => w.EndTime!.Value);
            stats.LatestEnd = latest.ToTimeSpan();
        }

        var daysWithBreaks = workDays.Where(w => w.Breaks.Any(b => b.StartTime.HasValue && b.EndTime.HasValue)).ToList();
        if (daysWithBreaks.Any())
        {
            var totalBreakTicks = daysWithBreaks.Sum(w => 
                w.Breaks.Where(b => b.StartTime.HasValue && b.EndTime.HasValue)
                        .Sum(b => (b.EndTime!.Value - b.StartTime!.Value).Ticks));
            stats.AverageBreak = TimeSpan.FromTicks(totalBreakTicks / daysWithBreaks.Count);
        }

        var allUserDays = await db.WorkDays
            .Where(w => w.UserId == userId && w.StartTime.HasValue && w.EndTime.HasValue)
            .OrderBy(w => w.Date)
            .Select(w => w.Date)
            .ToListAsync();

        if (allUserDays.Any())
        {
            int currentStreak = 1;
            int maxStreak = 1;
            int tempStreak = 1;

            for (int i = 1; i < allUserDays.Count; i++)
            {
                if (allUserDays[i].DayNumber == allUserDays[i - 1].DayNumber + 1)
                {
                    tempStreak++;
                }
                else if (allUserDays[i].DayNumber > allUserDays[i - 1].DayNumber + 1)
                {
                    if (tempStreak > maxStreak) maxStreak = tempStreak;
                    tempStreak = 1;
                }
            }
            if (tempStreak > maxStreak) maxStreak = tempStreak;

            stats.LongestStreak = maxStreak;

            var today = DateOnly.FromDateTime(DateTime.Today);
            var yesterday = today.AddDays(-1);
            if (allUserDays.Last() == today || allUserDays.Last() == yesterday)
            {
                stats.CurrentStreak = tempStreak;
            }
            else
            {
                stats.CurrentStreak = 0;
            }
        }

        return stats;
    }

    public async Task<DashboardChartDataVm> GetDashboardChartDataAsync(int userId, int year)
    {
        await using var db = await factory.CreateDbContextAsync();
        var chartData = new DashboardChartDataVm();
        var settings = await GetSettingsAsync(userId);
        var workDaysThisYear = await db.WorkDays
            .Include(w => w.Breaks)
            .Where(w => w.UserId == userId && w.Date.Year == year)
            .ToListAsync();

        var vacationsThisYear = await db.VacationDays
            .Where(v => v.UserId == userId && v.Date.Year == year)
            .ToListAsync();

        var holidaysThisYear = await db.PublicHolidays
            .Where(h => h.Date.Year == year && h.Counties.Contains(settings.GermanState))
            .ToListAsync();

        chartData.WorkDaysCount = workDaysThisYear.Count(w => w.StartTime.HasValue);
        chartData.VacationDaysCount = vacationsThisYear.Count;
        chartData.PublicHolidaysCount = holidaysThisYear.Count(h => settings.IsWorkDay(h.Date.DayOfWeek));

        for (int month = 1; month <= 12; month++)
        {
            var daysInMonth = workDaysThisYear.Where(w => w.Date.Month == month).ToList();
            if (!daysInMonth.Any(d => d.StartTime.HasValue)) continue;

            double monthOvertime = 0;
            foreach (var day in daysInMonth)
            {
                if (!day.StartTime.HasValue || !day.EndTime.HasValue) continue;
                
                var gross = day.EndTime.Value - day.StartTime.Value;
                var breakTicks = day.Breaks
                    .Where(b => b.StartTime.HasValue && b.EndTime.HasValue)
                    .Sum(b => (b.EndTime!.Value - b.StartTime!.Value).Ticks);
                
                var enteredBreak = TimeSpan.FromTicks(breakTicks);
                int minMinutes = gross.TotalHours >= 9.0 ? 45 : 30;
                int finalMin = Math.Max(minMinutes, settings.MinimumBreakMinutes);
                var minBreak = TimeSpan.FromMinutes(finalMin);
                var effectiveBreak = enteredBreak > minBreak ? enteredBreak : minBreak;
                
                var net = gross - effectiveBreak;
                var target = TimeSpan.FromHours(settings.DailyTargetHours);

                var isHoliday = holidaysThisYear.Any(h => h.Date == day.Date);
                var isVacation = vacationsThisYear.Any(v => v.Date == day.Date);
                var isWorkDay = settings.IsWorkDay(day.Date.DayOfWeek);

                if (!isWorkDay || isHoliday || isVacation) target = TimeSpan.Zero;

                monthOvertime += (net - target).TotalHours;
            }

            var monthName = new DateTime(year, month, 1).ToString("MMM", new System.Globalization.CultureInfo("de-DE"));
            chartData.MonthlyOvertime.Add(new MonthlyOvertimeVm { MonthName = monthName, OvertimeHours = monthOvertime });
        }

        return chartData;
    }
}