using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using ClosedXML;
using Erp.Platform.BlobStoring;
using Erp.Platform.Entities;
using Erp.Platform.FileManagement;
using Erp.Platform.Intranet;
using Microsoft.AspNetCore.Authorization;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.MultiTenancy;

namespace Erp.Platform.Public;

[Authorize]
public class IntranetAppService : PlatformAppService, IIntranetAppService
{
    private readonly ICurrentTenant _currentTenant;
    private readonly BlobManager _blobContainer;
    private readonly IConfiguration _configuration;

    private readonly IRepository<Event, Guid> _eventRepository;
    private readonly IRepository<Employee, Guid> _employeeRepository;
    private readonly IRepository<Visitor, Guid> _visitorRepository;
    private readonly IRepository<Reservation, Guid> _reservationRepository;
    private readonly IRepository<Training, Guid> _trainingRepository;
    private readonly IRepository<Expense, Guid> _expenseRepository;
    private readonly IRepository<Announcement, Guid> _announcementRepository;
    private readonly IRepository<Department, Guid> _departmentRepository;
    private readonly IRepository<ShuttleRoute, Guid> _shuttleRouteRepository;
    private readonly IRepository<Meal, Guid> _mealRepository;
    private readonly IRepository<Leave, Guid> _leaveRepository;
    private readonly IRepository<Overtime, Guid> _overtimeRepository;
    private readonly IRepository<Survey, Guid> _surveyRepository;
    private readonly IRepository<SocialPost, Guid> _socialPostRepository;

    public IntranetAppService(
        ICurrentTenant currentTenant,
        BlobManager blobContainer,
        IConfiguration configuration,

        IRepository<Event, Guid> eventRepository,
        IRepository<Employee, Guid> employeeRepository,
        IRepository<Visitor, Guid> visitorRepository,
        IRepository<Reservation, Guid> reservationRepository,
        IRepository<Training, Guid> trainingRepository,
        IRepository<Expense, Guid> expenseRepository,
        IRepository<Announcement, Guid> announcementRepository,
        IRepository<Department, Guid> departmentRepository,
        IRepository<ShuttleRoute, Guid> shuttleRouteRepository,
        IRepository<Meal, Guid> mealRepository,
        IRepository<Leave, Guid> leaveRepository,
        IRepository<Overtime, Guid> overtimeRepository,
        IRepository<Survey, Guid> surveyRepository,
        IRepository<SocialPost, Guid> socialPostRepository
    )
    {
        _currentTenant = currentTenant;
        _blobContainer = blobContainer;
        _configuration = configuration;

        _eventRepository = eventRepository;
        _employeeRepository = employeeRepository;
        _visitorRepository = visitorRepository;
        _reservationRepository = reservationRepository;
        _trainingRepository = trainingRepository;
        _expenseRepository = expenseRepository;
        _announcementRepository = announcementRepository;
        _departmentRepository = departmentRepository;
        _shuttleRouteRepository = shuttleRouteRepository;
        _mealRepository = mealRepository;
        _leaveRepository = leaveRepository;
        _overtimeRepository = overtimeRepository;
        _surveyRepository = surveyRepository;
        _socialPostRepository = socialPostRepository;
    }

    public async Task<IntranetDashboardDto> GetIntranetDashboardAsync()
    {
        return new IntranetDashboardDto
        {
            Events = await GetUpcomingEventsAsync(),
            Birthdays = await GetBirthdaysAsync(),
            Visitors = await GetVisitorsAsync(),
            Reservations = await GetReservationsAsync(),
            Trainings = await GetTrainingsAsync(),
            Expenses = await GetExpensesAsync(),
            Documents = await GetIntranetDocumentsAsync(BlobContainerNames.Intranet),
            Announcements = await GetAnnouncementsAsync(),
            ShuttleRoutes = await GetShuttleRoutesAsync(),
            Meals = await GetMealsAsync(),
            Leaves = await GetLeavesAsync(),
            Overtimes = await GetOvertimesAsync(),
            Surveys = await GetSurveysAsync(),
            SocialPosts = await GetSocialPostsAsync()
        };
    }

    private async Task<List<SocialPostDto>> GetSocialPostsAsync()
    {
        var socialPosts = await _socialPostRepository
            .WithDetailsAsync(e => e.Employee, e => e.Location, e => e.Media, e => e.Comments, e => e.Likes)
            .ContinueWith(t => t.Result.ToList());

        return ObjectMapper.Map<List<SocialPost>, List<SocialPostDto>>(socialPosts);
    }

    private async Task<List<SurveyDto>> GetSurveysAsync()
    {
        var queryable = await _surveyRepository.GetQueryableAsync();

        var surveys = queryable
            .Where(s => s.Status == "active")
            .Include(s => s.Questions)
                .ThenInclude(q => q.Options)
            .ToList();

        return ObjectMapper.Map<List<Survey>, List<SurveyDto>>(surveys);
    }

    private async Task<List<OvertimeDto>> GetOvertimesAsync()
    {
        var today = DateTime.Now;

        var overtimes = await _overtimeRepository
            .WithDetailsAsync(e => e.Employee)
            .ContinueWith(t => t.Result.ToList());

        return ObjectMapper.Map<List<Overtime>, List<OvertimeDto>>(overtimes);
    }

    private async Task<List<LeaveDto>> GetLeavesAsync()
    {
        var today = DateTime.Now;

        var leaves = await _leaveRepository
            .WithDetailsAsync(e => e.Employee)
            .ContinueWith(t => t.Result.ToList());

        return ObjectMapper.Map<List<Leave>, List<LeaveDto>>(leaves);
    }

    private async Task<List<MealDto>> GetMealsAsync()
    {
        // Bu haftanın başlangıç ve bitiş tarihlerini hesapla
        var today = DateTime.Now.Date;
        var dayOfWeek = (int)today.DayOfWeek;
        // Pazartesi'yi haftanın başı olarak kabul ediyoruz (ISO 8601)
        var weekStart = today.AddDays(-(dayOfWeek == 0 ? 6 : dayOfWeek - 1));
        var weekEnd = weekStart.AddDays(6);

        // Sadece bu haftanın yemeklerini getir
        var meals = await _mealRepository.GetListAsync(m =>
            m.Date >= weekStart && m.Date <= weekEnd);

        var mealDtos = new List<MealDto>();

        foreach (var meal in meals)
        {
            var dto = ObjectMapper.Map<Meal, MealDto>(meal);

            if (!string.IsNullOrEmpty(meal.Materials))
            {
                dto.Materials = meal.Materials
                    .Split('|', StringSplitOptions.RemoveEmptyEntries)
                    .Select(r => r.Trim())
                    .ToArray();
            }
            else
            {
                dto.Materials = [];
            }

            mealDtos.Add(dto);
        }

        return mealDtos;
    }

    private async Task<List<ShuttleRouteDto>> GetShuttleRoutesAsync()
    {
        var shuttleRoutes = await _shuttleRouteRepository.GetListAsync();

        var shuttleRouteDtos = new List<ShuttleRouteDto>();

        foreach (var shuttleRoute in shuttleRoutes)
        {
            var dto = ObjectMapper.Map<ShuttleRoute, ShuttleRouteDto>(shuttleRoute);

            // Route string'ini array'e çevir (pipe ile ayrılmış)
            if (!string.IsNullOrEmpty(shuttleRoute.Route))
            {
                dto.Route = shuttleRoute.Route
                    .Split('|', StringSplitOptions.RemoveEmptyEntries)
                    .Select(r => r.Trim())
                    .ToArray();
            }
            else
            {
                dto.Route = [];
            }

            shuttleRouteDtos.Add(dto);
        }

        return shuttleRouteDtos;
    }

    private async Task<List<AnnouncementDto>> GetAnnouncementsAsync()
    {
        var announcements = await _announcementRepository
            .WithDetailsAsync(e => e.Employee)
            .ContinueWith(t => t.Result.ToList());

        var announcementDtos = new List<AnnouncementDto>();

        // Tüm departmanları bir kez çek (performans için)
        var allDepartments = await _departmentRepository.GetListAsync();

        foreach (var announcement in announcements)
        {
            var dto = ObjectMapper.Map<Announcement, AnnouncementDto>(announcement);

            // Departments string'ini array'e çevir (pipe ile ayrılmış ID'ler)
            if (!string.IsNullOrEmpty(announcement.Departments))
            {
                var departmentIds = announcement.Departments
                    .Split('|', StringSplitOptions.RemoveEmptyEntries)
                    .Select(d => d.Trim())
                    .ToArray();

                // ID'leri Department Name'lere çevir
                var departmentNames = new List<string>();
                foreach (var deptId in departmentIds)
                {
                    if (Guid.TryParse(deptId, out var guid))
                    {
                        var department = allDepartments.FirstOrDefault(d => d.Id == guid);
                        if (department != null)
                        {
                            departmentNames.Add(department.Name);
                        }
                    }
                }

                dto.Departments = departmentNames.ToArray();
            }
            else
            {
                dto.Departments = [];
            }

            announcementDtos.Add(dto);
        }

        return announcementDtos;
    }

    private async Task<ExpensesDto> GetExpensesAsync()
    {
        var queryable = await _expenseRepository.GetQueryableAsync();

        var today = DateTime.Today;
        var oneMonthAgo = today.AddMonths(-1);

        // Son 1 ay içerisindeki kayıtlar
        var lastMonthExpenses = queryable
            .Where(a => a.RequestDate >= oneMonthAgo && a.RequestDate <= today);

        // Son 1 aydaki toplam talep miktarı
        var totalRequested = lastMonthExpenses.Sum(a => a.Amount);

        // Son 1 aydaki onaylanan harcamaların toplamı
        var totalApproved = lastMonthExpenses
            .Where(a => a.Status == "approved")
            .Sum(a => a.Amount);

        // Son 5 kayıt
        var last5Expenses = queryable
            .OrderByDescending(a => a.RequestDate)
            .Take(5)
            .ToList();

        // Map işlemleri
        var last5Dtos = ObjectMapper.Map<List<Expense>, List<ExpenseDto>>(last5Expenses);

        // Dönüş DTO'su
        return new ExpensesDto
        {
            TotalRequested = totalRequested,
            TotalApproved = totalApproved,
            Last5Expenses = last5Dtos
        };
    }

    private async Task<List<TrainingDto>> GetTrainingsAsync()
    {
        var trainings = await _trainingRepository.GetListAsync(a => a.StartDate >= DateTime.Today);

        return ObjectMapper.Map<List<Training>, List<TrainingDto>>(trainings);
    }

    private async Task<List<ReservationDto>> GetReservationsAsync()
    {
        var reservations = await _reservationRepository.GetListAsync(a => a.StartDate >= DateTime.Today);

        return ObjectMapper.Map<List<Reservation>, List<ReservationDto>>(reservations);
    }

    private async Task<List<VisitorDto>> GetVisitorsAsync()
    {
        var visitors = await _visitorRepository.GetListAsync(a => a.VisitDate >= DateTime.Today);

        return ObjectMapper.Map<List<Visitor>, List<VisitorDto>>(visitors);
    }

    private async Task<List<EmployeeDto>> GetBirthdaysAsync()
    {
        var today = DateTime.Now;

        var employees = await _employeeRepository
            .WithDetailsAsync(e => e.EmploymentType, e => e.JobPosition, e => e.Department)
            .ContinueWith(t => t.Result
                .Where(e => e.BirthDate.Day == today.Day && e.BirthDate.Month == today.Month)
                .ToList());

        return ObjectMapper.Map<List<Employee>, List<EmployeeDto>>(employees);
    }

    private async Task<List<EventDto>> GetUpcomingEventsAsync()
    {
        var events = await _eventRepository
            .WithDetailsAsync(e => e.Category, e => e.Type, e => e.Category, e => e.Photos, e => e.Comments)
            .ContinueWith(t => t.Result.ToList().Where(e => e.isPublished).OrderByDescending(e => e.CreationTime));

        var result = new List<EventDto>();
        foreach (var evt in events)
        {
            var employee = await _employeeRepository
                .WithDetailsAsync(e => e.JobPosition)
                .ContinueWith(t => t.Result.FirstOrDefault(e => e.Id == evt.EmployeeId));

            if (employee != null)
            {
                var calendarEvent = new EventDto
                {
                    Id = evt.Id.ToString(),
                    Name = evt.Name,
                    Description = evt.Description,
                    TypeName = evt.Type?.Name,
                    CategoryName = evt.Category?.Name,
                    Date = evt.Date,
                    Place = evt.Place,
                    Organizer = new EventOrganizerDto
                    {
                        Id = employee.Id,
                        Name = employee.Name,
                        Position = employee.JobPosition.Name,
                        Avatar = employee.Avatar
                    },
                    Participants = evt.ParticipantsCount,
                    Photos = [],
                    Comments = [],
                    Likes = evt.Likes,
                    IsPublished = evt.isPublished
                };

                // Comment'lerin author bilgilerini doldur
                if (evt.Comments != null && evt.Comments.Any())
                {
                    foreach (var comment in evt.Comments)
                    {
                        var commentAuthor = await _employeeRepository
                            .WithDetailsAsync(e => e.JobPosition)
                            .ContinueWith(t => t.Result.FirstOrDefault(e => e.Id == comment.EmployeeId));

                        if (commentAuthor != null)
                        {
                            calendarEvent.Comments.Add(new EventCommentDto
                            {
                                Id = comment.Id.ToString(),
                                Employee = new EventOrganizerDto
                                {
                                    Id = commentAuthor.Id,
                                    Name = commentAuthor.Name,
                                    Position = commentAuthor.JobPosition.Name,
                                    Avatar = commentAuthor.Avatar
                                },
                                Content = comment.Content,
                                CreationTime = comment.CreationTime,
                                Likes = comment.Likes
                            });
                        }
                    }
                }

                result.Add(calendarEvent);
            }
        }

        return result;
    }

    public async Task<List<FileItemDto>> GetIntranetDocumentsAsync(string folderPath)
    {
        var items = new List<FileItemDto>();
        var cdnBasePath = _configuration["App:CdnPath"];

        if (string.IsNullOrEmpty(cdnBasePath))
        {
            Logger.LogWarning("CDN path is not configured");
            return items;
        }

        var tenantId = _currentTenant.Id?.ToString() ?? "host";
        var fullPath = Path.Combine(cdnBasePath, tenantId);

        if (!string.IsNullOrEmpty(folderPath))
        {
            fullPath = Path.Combine(fullPath, folderPath);
        }

        if (!Directory.Exists(fullPath))
        {
            Logger.LogWarning($"Directory not found: {fullPath}");
            return items;
        }

        var files = Directory.GetFiles(fullPath);
        foreach (var file in files)
        {
            var fileInfo = new FileInfo(file);
            var relativePath = string.IsNullOrEmpty(folderPath) ? fileInfo.Name : $"{folderPath}/{fileInfo.Name}";

            items.Add(new FileItemDto
            {
                Id = Guid.NewGuid().ToString(),
                Name = fileInfo.Name,
                Type = "file",
                Size = fileInfo.Length,
                Extension = fileInfo.Extension,
                MimeType = GetMimeType(fileInfo.Extension),
                CreatedAt = fileInfo.CreationTime,
                ModifiedAt = fileInfo.LastWriteTime,
                Path = relativePath,
                ParentId = string.Empty,
                IsReadOnly = false,
                ChildCount = 0
            });
        }

        return items.OrderBy(x => x.Name).ToList();
    }

    private string GetMimeType(string extension)
    {
        return extension.ToLowerInvariant() switch
        {
            ".pdf" => "application/pdf",
            ".doc" => "application/msword",
            ".docx" => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
            ".xls" => "application/vnd.ms-excel",
            ".xlsx" => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            ".ppt" => "application/vnd.ms-powerpoint",
            ".pptx" => "application/vnd.openxmlformats-officedocument.presentationml.presentation",
            ".jpg" or ".jpeg" => "image/jpeg",
            ".png" => "image/png",
            ".gif" => "image/gif",
            ".txt" => "text/plain",
            ".zip" => "application/zip",
            ".rar" => "application/x-rar-compressed",
            _ => "application/octet-stream"
        };
    }
}