using Fitness_core_BE.Interfaces;
using Fitness_core_BE.Models;
using Microsoft.EntityFrameworkCore;

namespace Fitness_core_BE.Repos
{
    public class FacilityRepository : IFacilityRepository
    {
        private readonly TenantDbContext _context;

        public FacilityRepository(TenantDbContext context)
        {
            _context = context;
        }

        public async Task<List<Facility>> GetAllFacilities(Guid clientId, bool includeInactive = false)
        {
            var query = _context.Facilities.Where(f => f.FKClientId == clientId);
            if (!includeInactive)
                query = query.Where(f => f.IsActive);

            return await query.OrderBy(f => f.Name).ToListAsync();
        }

        public Task<Facility?> GetFacilityById(Guid facilityId)
            => _context.Facilities.FirstOrDefaultAsync(f => f.FacilityId == facilityId);

        public async Task<Facility> CreateFacility(Facility facility)
        {
            facility.FacilityId = Guid.NewGuid();
            facility.CreatedAt = DateTime.UtcNow;
            facility.IsActive = true;

            _context.Facilities.Add(facility);
            return facility;
        }

        public async Task<Facility> UpdateFacility(Facility facility)
        {
            var existing = await _context.Facilities.FindAsync(facility.FacilityId)
                ?? throw new KeyNotFoundException("Facility not found");

            existing.Name = facility.Name;
            existing.FacilityType = facility.FacilityType;
            existing.Description = facility.Description;
            existing.DefaultCapacity = facility.DefaultCapacity;
            existing.IsActive = facility.IsActive;

            return existing;
        }

        public async Task<Facility?> SetFacilityActive(Guid facilityId, Guid clientId, bool isActive)
        {
            var facility = await _context.Facilities
                .FirstOrDefaultAsync(f => f.FacilityId == facilityId && f.FKClientId == clientId);
            if (facility == null) return null;

            facility.IsActive = isActive;
            return facility;
        }

        public async Task<FacilitySession> CreateFacilitySession(FacilitySession session)
        {
            session.FacilitySessionId = Guid.NewGuid();
            session.CreatedAt = DateTime.UtcNow;
            session.IsCancelled = false;

            _context.FacilitySessions.Add(session);
            return session;
        }

        public Task<FacilitySession?> GetFacilitySessionById(Guid facilitySessionId)
            => _context.FacilitySessions
                .Include(s => s.Facility)
                .FirstOrDefaultAsync(s => s.FacilitySessionId == facilitySessionId);

        public async Task<List<FacilitySession>> GetSessions(Guid clientId, Guid? facilityId, DateTime fromUtc, DateTime toUtc)
        {
            var query = _context.FacilitySessions
                .Include(s => s.Facility)
                .Where(s => s.FKClientId == clientId && s.StartTime >= fromUtc && s.StartTime <= toUtc && !s.IsCancelled);

            if (facilityId.HasValue)
                query = query.Where(s => s.FKFacilityId == facilityId.Value);

            return await query.OrderBy(s => s.StartTime).ToListAsync();
        }

        public Task<int> GetActiveBookingCount(Guid facilitySessionId)
            => _context.Bookings.CountAsync(b => b.FKFacilitySessionId == facilitySessionId && b.Status != "Cancelled");

        public async Task<FacilitySession?> CancelFacilitySession(Guid facilitySessionId, Guid clientId)
        {
            var session = await _context.FacilitySessions
                .FirstOrDefaultAsync(s => s.FacilitySessionId == facilitySessionId && s.FKClientId == clientId);
            if (session == null) return null;

            session.IsCancelled = true;
            return session;
        }
    }
}