using AutoMapper;
using DigitalData.Core.Application;
using DigitalData.Core.DTO;
using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
using EnvelopeGenerator.Application.Resources;
using EnvelopeGenerator.Domain.Entities;
using EnvelopeGenerator.Application.Contracts.Repositories;
using Microsoft.Extensions.Localization;
using Microsoft.Extensions.Logging;
using EnvelopeGenerator.Extensions;
using EnvelopeGenerator.Application.DTOs.Messaging;
using EnvelopeGenerator.Application.Contracts.Services;
using EnvelopeGenerator.Application.Envelopes;
using EnvelopeGenerator.Application.Receivers.Queries.Read;

namespace EnvelopeGenerator.Application.Services;

public class EnvelopeReceiverService : BasicCRUDService<IEnvelopeReceiverRepository, EnvelopeReceiverDto, EnvelopeReceiver, (int Envelope, int Receiver)>, IEnvelopeReceiverService
{
    private readonly IStringLocalizer<Resource> _localizer;

    private readonly ISmsSender _smsSender;

    public EnvelopeReceiverService(IEnvelopeReceiverRepository repository, IStringLocalizer<Resource> localizer, IMapper mapper, ISmsSender smsSender)
        : base(repository, mapper)
    {
        _localizer = localizer;
        _smsSender = smsSender;
    }

    public async Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadBySignatureAsync(string signature, bool withEnvelope = false, bool withReceiver = true, bool readOnly = true)
    {
        var env_rcvs = await _repository.ReadBySignatureAsync(signature: signature, withEnvelope: withEnvelope, withReceiver: withReceiver, readOnly: readOnly);
        return Result.Success(_mapper.Map<IEnumerable<EnvelopeReceiverDto>>(env_rcvs));
    }

    public async Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadByUuidAsync(string uuid, bool withEnvelope = true, bool withReceiver = false, bool readOnly = true)
    {
        var env_rcvs = await _repository.ReadByUuidAsync(uuid: uuid, withEnvelope: withEnvelope, withReceiver: withReceiver, readOnly: readOnly);
        return Result.Success(_mapper.Map<IEnumerable<EnvelopeReceiverDto>>(env_rcvs));
    }

    public async Task<DataResult<IEnumerable<string?>>> ReadAccessCodeByUuidAsync(string uuid, bool withEnvelope = false, bool withReceiver = true)
    {
        var env_rcvs = await _repository.ReadByUuidAsync(uuid: uuid, withEnvelope: withEnvelope, withReceiver: withReceiver);
        return Result.Success(env_rcvs.Select(er => er.AccessCode));
    }

    public async Task<DataResult<EnvelopeReceiverDto>> ReadByUuidSignatureAsync(string uuid, string signature, bool withEnvelope = true, bool withReceiver = true, bool readOnly = true)
    {
        var env_rcv = await _repository.ReadByUuidSignatureAsync(uuid: uuid, signature: signature, withEnvelope: withEnvelope, withReceiver: withReceiver, readOnly: readOnly);
        if (env_rcv is null)
            return Result.Fail<EnvelopeReceiverDto>()
                .Message(Key.EnvelopeReceiverNotFound);

        return Result.Success(_mapper.Map<EnvelopeReceiverDto>(env_rcv));
    }

    public async Task<DataResult<EnvelopeReceiverSecretDto>> ReadWithSecretByUuidSignatureAsync(string uuid, string signature, bool withEnvelope = true, bool withReceiver = true, bool readOnly = true)
    {
        var env_rcv = await _repository.ReadByUuidSignatureAsync(uuid: uuid, signature: signature, withEnvelope: withEnvelope, withReceiver: withReceiver, readOnly: readOnly);
        if (env_rcv is null)
            return Result.Fail<EnvelopeReceiverSecretDto>()
                .Message(Key.EnvelopeReceiverNotFound);

        return Result.Success(_mapper.Map<EnvelopeReceiverSecretDto>(env_rcv));
    }

    public async Task<DataResult<EnvelopeReceiverDto>> ReadByEnvelopeReceiverIdAsync(string envelopeReceiverId, bool withEnvelope = true, bool withReceiver = true, bool readOnly = true)
    {
        (string? uuid, string? signature)  = envelopeReceiverId.DecodeEnvelopeReceiverId();

        if (uuid is null || signature is null)
            return Result.Fail<EnvelopeReceiverDto>()
                .Message(_localizer[Key.WrongEnvelopeReceiverId])
                .Notice(LogLevel.Warning, (uuid, signature).ToTitle())
                .Notice(LogLevel.Warning, EnvelopeFlag.WrongEnvelopeReceiverId)
                .Notice(LogLevel.Warning, Flag.PossibleSecurityBreach);

        return await ReadByUuidSignatureAsync(uuid: uuid, signature: signature, withEnvelope: withEnvelope, withReceiver: withReceiver, readOnly: readOnly);
    }

    public async Task<DataResult<bool>> VerifyAccessCodeAsync(string uuid, string signature, string accessCode)
    {
        var er = await _repository.ReadByUuidSignatureAsync(uuid: uuid, signature: signature);

        if (er is null)
            return Result.Fail<bool>()
                .Message(_localizer[Key.EnvelopeOrReceiverNonexists])
                .Notice(LogLevel.Warning, (uuid, signature).ToTitle())
                .Notice(LogLevel.Warning, EnvelopeFlag.EnvelopeOrReceiverNonexists)
                .Notice(LogLevel.Warning, Flag.PossibleDataIntegrityIssue);

        var actualAccessCode = er.AccessCode;

        if (actualAccessCode is null)
            return Result.Fail<bool>()
                .Message(_localizer[Key.AccessCodeNull])
                .Notice(LogLevel.Critical, (uuid, signature).ToTitle())
                .Notice(LogLevel.Critical, EnvelopeFlag.AccessCodeNull)
                .Notice(LogLevel.Critical, Flag.DataIntegrityIssue);

        else if (accessCode != actualAccessCode)
            return Result.Success(false).Message(_localizer[Key.WrongAccessCode]);
        else
            return Result.Success(true);
    }

    public async Task<DataResult<bool>> VerifyAccessCodeAsync(string envelopeReceiverId, string accessCode)
    {
        (string? uuid, string? signature) = envelopeReceiverId.DecodeEnvelopeReceiverId();

        if (uuid is null || signature is null)
            return Result.Fail<bool>()
                .Message(Key.WrongEnvelopeReceiverId)
                .Notice(LogLevel.Critical, EnvelopeFlag.WrongEnvelopeReceiverId)
                .Notice(LogLevel.Critical, Flag.SecurityBreach)
                .Notice(LogLevel.Critical, "Attempt to verify access code detected. Such actions are generally not initiated by well-intentioned users. Potential security breach suspected. Immediate investigation required.");

        return await VerifyAccessCodeAsync(uuid: uuid, signature: signature, accessCode: accessCode);
    }

    public async Task<DataResult<bool>> IsExisting(string envelopeReceiverId)
    {
        (string? uuid, string? signature) = envelopeReceiverId.DecodeEnvelopeReceiverId();

        if (uuid is null || signature is null)
            return Result.Fail<bool>().Notice(LogLevel.Warning, EnvelopeFlag.NonDecodableEnvelopeReceiverId, "In IsExisting(string envelopeReceiverId)");

        int count = await _repository.CountAsync(uuid:uuid, signature:signature);
        return Result.Success(count > 0);
    }

		public async Task<DataResult<string>> ReadAccessCodeByIdAsync(int envelopeId, int receiverId)
		{
        var code = await _repository.ReadAccessCodeByIdAsync(envelopeId: envelopeId, receiverId: receiverId);
        return code is null ? 
            Result.Fail<string>().Notice(LogLevel.Error, Flag.DataIntegrityIssue, $"Access code is null. Envelope ID is {envelopeId} and receiver ID {receiverId}")
            : Result.Success(code);
		}

    public async Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadByUsernameAsync(string username, int? min_status = null, int? max_status = null, EnvelopeQuery? envelopeQuery = null, ReadReceiverQuery? receiverQuery = null, params int[] ignore_statuses)
    {
        var er_list = await _repository.ReadByUsernameAsync(username: username, min_status: min_status, max_status: max_status, ignore_statuses: ignore_statuses);
        
        if(envelopeQuery?.Id is int eId)
            er_list = er_list.Where(er => er.EnvelopeId == eId);

        if (envelopeQuery?.Uuid is string uuid)
            er_list = er_list.Where(er => er.Envelope?.Uuid == uuid);

        if (envelopeQuery?.Status is int status)
            er_list = er_list.Where(er => er.Envelope?.Status == status);

        if(receiverQuery?.Id is int id)
            er_list = er_list.Where(er => er.Receiver?.Id == id);

        if (receiverQuery?.Signature is string signature)
            er_list = er_list.Where(er => er.Receiver?.Signature == signature);

        var dto_list = _mapper.Map<IEnumerable<EnvelopeReceiverDto>>(er_list);
        return Result.Success(dto_list);
    }

    public async Task<DataResult<string?>> ReadLastUsedReceiverNameByMail(string mail)
    {
        var er = await _repository.ReadLastByReceiver(mail);
        return er is null ? Result.Fail<string?>().Notice(LogLevel.None, Flag.NotFound) : Result.Success(er.Name);
    }

    public async Task<DataResult<SmsResponse>> SendSmsAsync(string envelopeReceiverId, string message)
    {
        (string? uuid, string? signature) = envelopeReceiverId.DecodeEnvelopeReceiverId();

        if (uuid is null || signature is null)
            return Result.Fail<SmsResponse>()
                .Message(_localizer[Key.WrongEnvelopeReceiverId])
                .Notice(LogLevel.Warning, (uuid, signature).ToTitle())
                .Notice(LogLevel.Warning, EnvelopeFlag.WrongEnvelopeReceiverId)
                .Notice(LogLevel.Warning, Flag.PossibleSecurityBreach);

        var env_rcv = await _repository.ReadByUuidSignatureAsync(uuid: uuid, signature: signature, withEnvelope: false, withReceiver: false);
        if (env_rcv is null)
            return Result.Fail<SmsResponse>()
                .Message(Key.EnvelopeReceiverNotFound);

        if (env_rcv.PhoneNumber is null)
            return Result.Fail<SmsResponse>()
                .Message(Key.PhoneNumberNonexists)
                .Notice(LogLevel.Error, Flag.NotFound, $"An attempt was made to send sms to the user whose phone number is null. Envelope recipient ID is {envelopeReceiverId}, UUID is {uuid} and signature is {signature}.");

        var res = await _smsSender.SendSmsAsync(recipient: env_rcv.PhoneNumber, message: message);

        return Result.Success(res);
    }

    public Task<DataResult<IEnumerable<EnvelopeReceiverSecretDto>>> ReadWithSecretByUuidAsync(string uuid)
    {
        throw new NotImplementedException();
    }
}