using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using vendorApproverBackend.Data;
using vendorApproverBackend.Services;
using vendorApproverBackend.Responses;
using vendorApproverBackend.Entities;
using vendorApproverBackend.Requests;
using vendorApproverBackend.Interfaces;



namespace vendorApproverBackend.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    [AllowAnonymous]
    public class VendorsController : ControllerBase
    {
        private readonly UserService _userService;
        private readonly VendorService _vendorService;
        private readonly IOtpGenerate _otpGenerate;
        private readonly IEmailService _emailService;
        private readonly DataContext _context;

        public VendorsController(UserService userService, IEmailService emailService, VendorService vendorService,
         DataContext context, IOtpGenerate otpGenerate)
        {
            _userService = userService;
            _vendorService = vendorService;
            _context = context;
            _otpGenerate = otpGenerate;
            _emailService = emailService;
        }


        [HttpGet]
        public async Task<ActionResult<PagedResult<User>>> GetAllVendors(
            [FromQuery] int page = 0,
            [FromQuery] int size = 5,
            [FromQuery] string? search = null,  
            [FromQuery] bool? active = null,
            [FromQuery] long? id = null)
        {
            var result = await _userService.GetVendorsAsync(page, size, search, active, id);
            return Ok(result);
        }

        // 2. DELETE: api/Vendors/{userId}
        [HttpDelete("{userId}")]
        public async Task<IActionResult> DeleteVendor(long userId)
        {
            var deleted = await _userService.DeleteUserAsync(userId);
            if (!deleted) return NotFound(new { message = "User not found" });

            return Ok(new { message = "Vendor deleted successfully" });
        }

        // 3. PATCH/GET: api/Vendors/toggle-active/{userId}
        [HttpGet("toggle-active/{userId}")]
        public async Task<IActionResult> ToggleActive(long userId)
        {
            var user = await _userService.ToggleUserActiveAsync(userId);
            if (user == null) return NotFound(new { message = "User not found" });

            return Ok(user);
        }
    


    [HttpPost("add_vendor")]
        [Authorize(Roles = "ADMIN")]
        public async Task<IActionResult> SignupVendor([FromForm] SignUpVendorRequest request)
        {
            if (string.IsNullOrWhiteSpace(request.Email) || string.IsNullOrWhiteSpace(request.Password))
                return BadRequest("Email and password cannot be empty.");

            if (await _userService.ExistByEmailAsync(request.Email.ToLower()))
                return BadRequest("Email already exists.");

            try
            {
                _ = new System.Net.Mail.MailAddress(request.Email);
            }
            catch
            {
                return BadRequest("Email is not valid.");
            }

            await using var transaction = await _context.Database.BeginTransactionAsync();
            try
            {
                var userCount = await _userService.GetUserCountAsync();
                var username = _userService.GenerateUsername(request.Name, userCount);

                var user = new User
                {
                    Name = request.Name,
                    Email = request.Email.ToLower(),
                    Password = request.Password,
                    City = request.City,
                    Country = request.Country,
                    Username = username,
                    Active = false
                };

                var vendor = new Vendor
                {
                    ManifactoryName = request.ManifactoryName,
                    LocalAgentName = request.LocalAgentName,
                    LocalAgentPhone = request.LocalAgentPhone,
                    CommercialRegistrationNo = request.CommercialRegistrationNo,
                    RepresentativeName = request.RepresentativeName,
                    RepresentativeEmail = request.RepresentativeEmail,
                    Position = request.Position,
                    PartnerCompany = request.PartnerCompany,
                    User = user
                };

                user.Vendor = vendor;

                // Generate OTP and assign to user
                /* var otpKey = !string.IsNullOrWhiteSpace(vendor.LocalAgentPhone)
                             ? vendor.LocalAgentPhone
                             : user.Email; */

                user.Active = true;

                // Save user and vendor (ensure SaveVendorAsync saves everything)
                var createdUser = await _userService.SaveVendorAsync(user);

                await transaction.CommitAsync();

                /* try
                {
                    await _emailService.SendOtpEmailAsync(user.Email, user, otp);
                }
                catch
                {
                } */

                return Ok(createdUser);
            }
            catch (Exception e)
            {
                await transaction.RollbackAsync();
                return StatusCode(500, "An internal error occurred while creating the vendor.");
            }
        }

    }
}