using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using foundation_system.Data;
using foundation_system.Models;
using foundation_system.Models.ViewModels;

namespace foundation_system.Controllers;

[Authorize]
public class ColaboradorController : Controller
{
    private readonly ApplicationDbContext _context;

    public ColaboradorController(ApplicationDbContext context)
    {
        _context = context;
    }

    // GET: Colaborador
    public async Task<IActionResult> Index()
    {
        var colaboradores = await _context.Colaboradores
            .Include(c => c.Persona)
            .Include(c => c.Cargo)
            .OrderBy(c => c.Persona.Apellidos)
            .ToListAsync();
        return View(colaboradores);
    }

    // GET: Colaborador/Create
    public async Task<IActionResult> Create()
    {
        ViewBag.Cargos = await _context.CargosColaboradores.Where(c => c.Activo).OrderBy(c => c.Nombre).ToListAsync();
        return View(new ColaboradorViewModel());
    }

    // POST: Colaborador/Create
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Create(ColaboradorViewModel model)
    {
        if (ModelState.IsValid)
        {
            using var transaction = await _context.Database.BeginTransactionAsync();
            try
            {
                var persona = new Persona
                {
                    Nombres = model.Nombres,
                    Apellidos = model.Apellidos,
                    Dui = model.Dui,
                    Nit = model.Nit,
                    FechaNacimiento = model.FechaNacimiento,
                    Genero = model.Genero,
                    Email = model.Email,
                    Telefono = model.Telefono,
                    Direccion = model.Direccion,
                    Activo = true
                };

                _context.Personas.Add(persona);
                await _context.SaveChangesAsync();

                var colaborador = new Colaborador
                {
                    PersonaId = persona.Id,
                    CargoId = model.CargoId,
                    TipoColaborador = model.TipoColaborador,
                    FechaIngreso = model.FechaIngreso,
                    HorarioEntrada = model.HorarioEntrada,
                    HorarioSalida = model.HorarioSalida,
                    Activo = true
                };

                _context.Colaboradores.Add(colaborador);
                await _context.SaveChangesAsync();

                await transaction.CommitAsync();
                TempData["SuccessMessage"] = "Colaborador creado exitosamente.";
                return RedirectToAction(nameof(Index));
            }
            catch (Exception)
            {
                await transaction.RollbackAsync();
                ModelState.AddModelError("", "Ocurrió un error al guardar el colaborador.");
            }
        }
        ViewBag.Cargos = await _context.CargosColaboradores.Where(c => c.Activo).OrderBy(c => c.Nombre).ToListAsync();
        return View(model);
    }

    // GET: Colaborador/Edit/5
    public async Task<IActionResult> Edit(long? id)
    {
        if (id == null) return NotFound();

        var colaborador = await _context.Colaboradores
            .Include(c => c.Persona)
            .Include(c => c.Cargo)
            .FirstOrDefaultAsync(c => c.Id == id);

        if (colaborador == null) return NotFound();

        var model = new ColaboradorViewModel
        {
            Id = colaborador.Id,
            PersonaId = colaborador.PersonaId,
            Nombres = colaborador.Persona.Nombres,
            Apellidos = colaborador.Persona.Apellidos,
            Dui = colaborador.Persona.Dui,
            Nit = colaborador.Persona.Nit,
            FechaNacimiento = colaborador.Persona.FechaNacimiento,
            Genero = colaborador.Persona.Genero,
            Email = colaborador.Persona.Email,
            Telefono = colaborador.Persona.Telefono,
            Direccion = colaborador.Persona.Direccion,
            CargoId = colaborador.CargoId,
            TipoColaborador = colaborador.TipoColaborador,
            FechaIngreso = colaborador.FechaIngreso,
            HorarioEntrada = colaborador.HorarioEntrada,
            HorarioSalida = colaborador.HorarioSalida,
            Activo = colaborador.Activo
        };

        ViewBag.Cargos = await _context.CargosColaboradores.Where(c => c.Activo).OrderBy(c => c.Nombre).ToListAsync();
        return View(model);
    }

    // POST: Colaborador/Edit/5
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Edit(long id, ColaboradorViewModel model)
    {
        if (id != model.Id) return NotFound();

        if (ModelState.IsValid)
        {
            using var transaction = await _context.Database.BeginTransactionAsync();
            try
            {
                var colaborador = await _context.Colaboradores
                    .Include(c => c.Persona)
                    .FirstOrDefaultAsync(c => c.Id == id);

                if (colaborador == null) return NotFound();

                // Update Persona
                colaborador.Persona.Nombres = model.Nombres;
                colaborador.Persona.Apellidos = model.Apellidos;
                colaborador.Persona.Dui = model.Dui;
                colaborador.Persona.Nit = model.Nit;
                colaborador.Persona.FechaNacimiento = model.FechaNacimiento;
                colaborador.Persona.Genero = model.Genero;
                colaborador.Persona.Email = model.Email;
                colaborador.Persona.Telefono = model.Telefono;
                colaborador.Persona.Direccion = model.Direccion;

                // Update Colaborador
                colaborador.CargoId = model.CargoId;
                colaborador.TipoColaborador = model.TipoColaborador;
                colaborador.FechaIngreso = model.FechaIngreso;
                colaborador.HorarioEntrada = model.HorarioEntrada;
                colaborador.HorarioSalida = model.HorarioSalida;
                colaborador.Activo = model.Activo;
                colaborador.ActualizadoEn = DateTime.UtcNow;

                await _context.SaveChangesAsync();
                await transaction.CommitAsync();

                TempData["SuccessMessage"] = "Colaborador actualizado exitosamente.";
                return RedirectToAction(nameof(Index));
            }
            catch (Exception)
            {
                await transaction.RollbackAsync();
                ModelState.AddModelError("", "Ocurrió un error al actualizar el colaborador.");
            }
        }
        ViewBag.Cargos = await _context.CargosColaboradores.Where(c => c.Activo).OrderBy(c => c.Nombre).ToListAsync();
        return View(model);
    }

    // POST: Colaborador/Delete/5
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Delete(long id)
    {
        var colaborador = await _context.Colaboradores.FindAsync(id);
        if (colaborador != null)
        {
            colaborador.Activo = false; // Soft delete
            await _context.SaveChangesAsync();
            TempData["SuccessMessage"] = "Colaborador desactivado exitosamente.";
        }
        return RedirectToAction(nameof(Index));
    }
}
