using Api.SeaHavenIndustries.DTOs;
using Data.SeaHavenIndustries;
using FluentValidation;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using SeaHaven.Services.Interfaces;
using SeaHaven.Services.DTOs;
using System.Security.Claims;

[ApiController]
[Route("api/Account")]
[Route("api/accounts")]
public class AccountController : ControllerBase
{
    private readonly IAccountService _accountService;

    public AccountController(IAccountService accountService)
    {
        _accountService = accountService;
    }

    // -----------------------------------
    // POST: api/Account/AddAccounts
    // -----------------------------------
    [HttpPost("AddAccounts")]
    public async Task<IActionResult> AddAccounts(Account_DTO dto)
    {
        try
        {
            var createDto = new CreateAccountDTO
            {
                Name = dto.Name ?? throw new ArgumentException("Name is required"),
                Phone = dto.Phone,
                Email = dto.Email,
                Website = dto.Website
            };

            var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
            if (userId == null)
                return Unauthorized(new Response { Status = "Error", Message = "User not authenticated" });

            await _accountService.CreateAccountAsync(createDto, userId);

            return Ok(new DataResponse
            {
                Message = "Account added successfully.",
                Status = "200"
            });
        }
        catch (ValidationException vex)
        {
            var errors = string.Join(", ", vex.Errors.Select(e => e.ErrorMessage));
            return BadRequest(new Response { Status = "Validation Error", Message = errors });
        }
        catch (Exception ex)
        {
            return StatusCode(500, new Response { Status = "Error", Message = ex.Message });
        }
    }

    // -----------------------------------
    // POST: api/Account/EditAccounts
    // -----------------------------------
    [HttpPost("EditAccounts")]
    public async Task<IActionResult> EditAccounts(EditAccount_DTO dto)
    {
        try
        {
            var updateDto = new UpdateAccountDTO
            {
                Name = dto.Name,
                Phone = dto.Phone,
                Email = dto.Email,
                Website = dto.Website
            };

            var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
            if (userId == null)
                return Unauthorized(new Response { Status = "Error", Message = "User not authenticated" });

            await _accountService.UpdateAccountAsync(dto.Id, updateDto, userId);

            return Ok(new DataResponse
            {
                Message = "Account updated successfully.",
                Status = "200"
            });
        }
        catch (ValidationException vex)
        {
            var errors = string.Join(", ", vex.Errors.Select(e => e.ErrorMessage));
            return BadRequest(new Response { Status = "Validation Error", Message = errors });
        }
        catch (KeyNotFoundException)
        {
            return NotFound(new Response { Status = "Error", Message = "Account not found" });
        }
        catch (Exception ex)
        {
            return StatusCode(500, new Response { Status = "Error", Message = ex.Message });
        }
    }

    // -----------------------------------
    // GET: api/Account/DeleteAccounts?id=5
    // -----------------------------------
    [HttpGet("DeleteAccounts")]
    public async Task<IActionResult> DeleteAccounts(int id)
    {
        try
        {
            var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
            if (userId == null)
                return Unauthorized(new Response { Status = "Error", Message = "User not authenticated" });

            await _accountService.DeleteAccountAsync(id, userId);

            return Ok(new DataResponse
            {
                Message = "Account deleted successfully.",
                Status = "200"
            });
        }
        catch (KeyNotFoundException)
        {
            return NotFound(new Response { Status = "Error", Message = "Account not found" });
        }
        catch (Exception ex)
        {
            return StatusCode(500, new Response { Status = "Error", Message = ex.Message });
        }
    }

    // -----------------------------------
    // GET: api/Account/GetAccountList?search=&page=&pageSize=
    // -----------------------------------
    [HttpGet("GetAccountList")]
    public async Task<IActionResult> GetAccountList(string? search = "", int page = 1, int pageSize = 12)
    {
        var pagedResult = await _accountService.GetAccountsPagedAsync(page, pageSize, search);

        var data = pagedResult.Items.Select(a => new
        {
            Id = a.Id,
            Name = a.Name,
            Type = a.Type ?? "",
            Phone = a.Phone,
            Email = a.Email,
            Industry = (int?)null, // Map if needed
            Website = a.Website
        });

        var viewModel = new Pagination_DTO
        {
            Data = data,
            PageNumber = page,
            PageSize = pageSize,
            TotalCount = pagedResult.TotalCount,
            TotalPages = (int)Math.Ceiling(pagedResult.TotalCount / (double)pageSize)
        };

        return Ok(viewModel);
    }
}