using Nuuru.Server.DTOs.Moderation;
using Nuuru.Server.Models;
using AuditLog = Nuuru.Server.Models.AuditLog;

namespace Nuuru.Server.Extensions
{
    /// <summary>
    /// Extension methods for mapping between moderation entities and DTOs
    /// </summary>
    public static class ModerationMappingExtensions
    {
        /// <summary>
        /// Maps an ApplicationUser to ModeratorDto
        /// </summary>
        public static ModeratorDto ToModeratorDto(this ApplicationUser user)
        {
            if (user == null) return null;

            return new ModeratorDto
            {
                Id = user.Id,
                UserName = user.UserName
            };
        }

        /// <summary>
        /// Maps an ApplicationUser to UserDto
        /// </summary>
        public static UserDto ToUserDto(this ApplicationUser user)
        {
            if (user == null) return null;

            return new UserDto
            {
                Id = user.Id,
                UserName = user.UserName
            };
        }

        /// <summary>
        /// Maps a ModerationAction entity to ModerationActionDto
        /// </summary>
        public static ModerationActionDto ToDto(this ModerationAction action)
        {
            if (action == null) return null;

            return new ModerationActionDto
            {
                Id = action.Id,
                Action = action.Action,
                TargetType = action.TargetType,
                TargetId = action.TargetId,
                Reason = action.Reason,
                Details = action.Details,
                Timestamp = action.Timestamp,
                Moderator = action.Moderator?.ToModeratorDto()
            };
        }

        /// <summary>
        /// Maps a Ban entity to BanDto
        /// </summary>
        public static BanDto ToDto(this Ban ban)
        {
            if (ban == null) return null;

            return new BanDto
            {
                Id = ban.Id,
                Reason = ban.Reason,
                StartTime = ban.StartTime,
                EndTime = ban.EndTime,
                Zone = ban.Zone,
                Active = ban.Active,
                IsBanActive = ban.IsBanActive(),
                AppealsDenied = ban.AppealsDenied,
                User = ban.User?.ToUserDto()
            };
        }

        /// <summary>
        /// Maps a collection of ModerationActions to ModerationActionDtos
        /// </summary>
        public static List<ModerationActionDto> ToDto(this IEnumerable<ModerationAction> actions)
        {
            return actions?.Select(a => a.ToDto()).ToList() ?? new List<ModerationActionDto>();
        }

        /// <summary>
        /// Maps a collection of Bans to BanDtos
        /// </summary>
        public static List<BanDto> ToDto(this IEnumerable<Ban> bans)
        {
            return bans?.Select(b => b.ToDto()).ToList() ?? new List<BanDto>();
        }

        /// <summary>
        /// Maps an IpBan entity to IpBanDto
        /// </summary>
        public static IpBanDto ToDto(this IpBan ipBan)
        {
            if (ipBan == null) return null;

            return new IpBanDto
            {
                Id = ipBan.Id,
                IpAddress = ipBan.IpAddress,
                Reason = ipBan.Reason,
                StartTime = ipBan.StartTime,
                EndTime = ipBan.EndTime,
                Active = ipBan.Active,
                IsActive = ipBan.IsActive(),
                CreatedBy = ipBan.CreatedBy?.ToUserDto()
            };
        }

        /// <summary>
        /// Maps a collection of IpBans to IpBanDtos
        /// </summary>
        public static List<IpBanDto> ToDto(this IEnumerable<IpBan> ipBans)
        {
            return ipBans?.Select(b => b.ToDto()).ToList() ?? new List<IpBanDto>();
        }

        /// <summary>
        /// Maps a Report entity to ReportDto
        /// </summary>
        public static ReportDto ToDto(this Report report, ReportTargetPreviewDto? targetPreview = null)
        {
            if (report == null) return null;

            return new ReportDto
            {
                Id = report.Id,
                TargetType = report.TargetType.ToString(),
                TargetId = report.TargetId,
                Reason = report.Reason,
                Status = report.Status.ToString(),
                CreatedAt = report.CreatedAt,
                ResolvedAt = report.ResolvedAt,
                ResolutionNote = report.ResolutionNote,
                Reporter = report.Reporter?.ToUserDto(),
                Moderator = report.Moderator?.ToModeratorDto(),
                TargetPreview = targetPreview
            };
        }

        /// <summary>
        /// Maps a collection of Reports to ReportDtos
        /// </summary>
        public static List<ReportDto> ToDto(this IEnumerable<Report> reports)
        {
            return reports?.Select(r => r.ToDto()).ToList() ?? new List<ReportDto>();
        }

        /// <summary>
        /// Maps a BanAppeal entity to BanAppealDto
        /// </summary>
        public static BanAppealDto ToDto(this BanAppeal appeal)
        {
            if (appeal == null) return null;

            return new BanAppealDto
            {
                Id = appeal.Id,
                BanId = appeal.BanId,
                Reason = appeal.Reason,
                Status = appeal.Status.ToString(),
                CreatedAt = appeal.CreatedAt,
                ResolvedAt = appeal.ResolvedAt,
                ModeratorNote = appeal.ModeratorNote,
                User = appeal.User?.ToUserDto(),
                Moderator = appeal.Moderator?.ToModeratorDto(),
                Ban = appeal.Ban?.ToDto()
            };
        }

        /// <summary>
        /// Maps a collection of BanAppeals to BanAppealDtos
        /// </summary>
        public static List<BanAppealDto> ToDto(this IEnumerable<BanAppeal> appeals)
        {
            return appeals?.Select(a => a.ToDto()).ToList() ?? new List<BanAppealDto>();
        }

        /// <summary>
        /// Maps an IpBanAppeal entity to IpBanAppealDto
        /// </summary>
        public static IpBanAppealDto ToDto(this IpBanAppeal appeal)
        {
            if (appeal == null) return null;

            return new IpBanAppealDto
            {
                Id = appeal.Id,
                IpBanId = appeal.IpBanId,
                IpAddress = appeal.IpAddress,
                Reason = appeal.Reason,
                Status = appeal.Status.ToString(),
                CreatedAt = appeal.CreatedAt,
                ResolvedAt = appeal.ResolvedAt,
                ModeratorNote = appeal.ModeratorNote,
                User = appeal.User?.ToUserDto(),
                Moderator = appeal.Moderator?.ToModeratorDto(),
                IpBan = appeal.IpBan?.ToDto()
            };
        }

        /// <summary>
        /// Maps a collection of IpBanAppeals to IpBanAppealDtos
        /// </summary>
        public static List<IpBanAppealDto> ToDto(this IEnumerable<IpBanAppeal> appeals)
        {
            return appeals?.Select(a => a.ToDto()).ToList() ?? new List<IpBanAppealDto>();
        }

        /// <summary>
        /// Maps an AuditLog entity to AuditLogDto
        /// </summary>
        public static AuditLogDto ToAuditLogDto(this AuditLog auditLog)
        {
            if (auditLog == null) return null;

            return new AuditLogDto
            {
                Id = auditLog.Id,
                Action = auditLog.Action,
                Category = auditLog.Category,
                TargetType = auditLog.TargetType,
                TargetId = auditLog.TargetId,
                IpAddress = auditLog.IpAddress,
                AssessmentId = auditLog.AssessmentId,
                BrowserHash = auditLog.BrowserHash,
                HttpMethod = auditLog.HttpMethod,
                RequestPath = auditLog.RequestPath,
                ResponseStatusCode = auditLog.ResponseStatusCode,
                Timestamp = auditLog.Timestamp,
                User = auditLog.User?.ToUserDto()
            };
        }
    }
}