using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Asistencia.Models;
using Asistencia.Services;
using System.Collections.ObjectModel;

namespace Asistencia.ViewModels;

public partial class AsistenciaViewModel : ObservableObject
{
    private readonly AsistenciaService _asistenciaService;
    private readonly AuthService _authService;
    private readonly MainWindowViewModel _mainVm;
    private readonly CursoAbierto _curso;

    [ObservableProperty]
    private string _nombreCurso = string.Empty;

    [ObservableProperty]
    private string _infoCurso = string.Empty;

    [ObservableProperty]
    private bool _enSesion;

    [ObservableProperty]
    private int _totalAlumnos;

    [ObservableProperty]
    private int _presentes;

    [ObservableProperty]
    private int _tardanzas;

    [ObservableProperty]
    private int _ausentes;

    [ObservableProperty]
    private string _mensajeEstado = string.Empty;

    public ObservableCollection<AlumnoAsistenciaViewModel> Alumnos { get; } = new();

    public AsistenciaViewModel(AsistenciaService asistenciaService, AuthService authService, CursoAbierto curso, MainWindowViewModel mainVm)
    {
        _asistenciaService = asistenciaService;
        _authService = authService;
        _mainVm = mainVm;
        _curso = curso;

        NombreCurso = curso.Curso?.NombreCurso ?? "Curso";
        InfoCurso = $"{curso.Sala} | {curso.Sede} | {curso.HoraInicio} - {curso.HoraFin}";

        _ = InitAsync();
    }

    private async Task InitAsync()
    {
        var sesion = await _asistenciaService.BuscarSesionActivaAsync(_curso.IdCursoAbierto);
        EnSesion = sesion != null;

        var alumnos = await _asistenciaService.ObtenerAlumnosAsync(_curso.IdCursoAbierto);
        var asistencias = await _asistenciaService.ObtenerAsistenciaAlumnosAsync(_curso.IdCursoAbierto);

        Alumnos.Clear();
        foreach (var alumno in alumnos)
        {
            var tipo = asistencias.TryGetValue(alumno.IdDetalleContrato, out var t) ? t : TipoAsistencia.Ausente;
            Alumnos.Add(new AlumnoAsistenciaViewModel(alumno, tipo));
        }

        TotalAlumnos = Alumnos.Count;
        ActualizarContadores();

        MensajeEstado = EnSesion
            ? "Sesion en curso - Puede registrar asistencia"
            : "Inicie la sesion para registrar asistencia";
    }

    [RelayCommand]
    private async Task IniciarSesionAsync()
    {
        if (_authService.CurrentUser == null) return;

        await _asistenciaService.IniciarSesionAsync(_curso.IdCursoAbierto, _authService.CurrentUser.RutPasaporte);
        EnSesion = true;
        MensajeEstado = "Sesion iniciada - Registre la asistencia de los alumnos";
    }

    [RelayCommand]
    private async Task FinalizarSesionAsync()
    {
        var sesion = await _asistenciaService.BuscarSesionActivaAsync(_curso.IdCursoAbierto);
        if (sesion != null)
        {
            await _asistenciaService.FinalizarSesionAsync(sesion.Id);
        }
        EnSesion = false;
        MensajeEstado = "Sesion finalizada";
    }

    [RelayCommand]
    private async Task MarcarAlumnoAsync(AlumnoAsistenciaViewModel? alumno)
    {
        if (alumno == null || !EnSesion) return;

        alumno.CiclarTipoAsistencia();
        await _asistenciaService.GuardarAsistenciaAlumnoAsync(alumno.IdDetalleContrato, alumno.TipoAsistencia);
        ActualizarContadores();
    }

    [RelayCommand]
    private void Volver()
    {
        _mainVm.NavigateToDashboard();
    }

    private void ActualizarContadores()
    {
        Presentes = Alumnos.Count(a => a.TipoAsistencia == Models.TipoAsistencia.Presente);
        Tardanzas = Alumnos.Count(a => a.TipoAsistencia == Models.TipoAsistencia.Tardanza);
        Ausentes = Alumnos.Count(a => a.TipoAsistencia == Models.TipoAsistencia.Ausente);
    }
}

public partial class AlumnoAsistenciaViewModel : ObservableObject
{
    public int IdDetalleContrato { get; }
    public string NombreCompleto { get; }

    [ObservableProperty]
    private int _tipoAsistencia;

    [ObservableProperty]
    private string _tipoAsistenciaTexto;

    [ObservableProperty]
    private string _tipoAsistenciaColor;

    public AlumnoAsistenciaViewModel(DetalleContrato alumno, int tipoInicial)
    {
        IdDetalleContrato = alumno.IdDetalleContrato;
        NombreCompleto = alumno.NombreCompleto;
        TipoAsistencia = tipoInicial;
        ActualizarDisplay();
    }

    public void CiclarTipoAsistencia()
    {
        TipoAsistencia = TipoAsistencia switch
        {
            Models.TipoAsistencia.Presente => Models.TipoAsistencia.Tardanza,
            Models.TipoAsistencia.Tardanza => Models.TipoAsistencia.Ausente,
            _ => Models.TipoAsistencia.Presente
        };
        ActualizarDisplay();
    }

    private void ActualizarDisplay()
    {
        TipoAsistenciaTexto = Models.TipoAsistencia.Nombre(TipoAsistencia);
        TipoAsistenciaColor = TipoAsistencia switch
        {
            Models.TipoAsistencia.Presente => "#28A745",
            Models.TipoAsistencia.Tardanza => "#FFC107",
            _ => "#DC3545"
        };
    }
}