using System;
using System.Threading.Tasks;
using Erp.SqlQueryManager.Application.Contracts;
using Erp.SqlQueryManager.Domain.Entities;
using Erp.SqlQueryManager.Domain.Services;
using Microsoft.AspNetCore.Mvc;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;

namespace Erp.SqlQueryManager.Application;

public class SqlStoredProcedureAppService : CrudAppService<
    SqlStoredProcedure,
    SqlStoredProcedureDto,
    Guid,
    PagedAndSortedResultRequestDto,
    CreateSqlStoredProcedureDto,
    UpdateSqlStoredProcedureDto>, ISqlStoredProcedureAppService
{
    private readonly ISqlExecutorService _sqlExecutorService;

    public SqlStoredProcedureAppService(
        IRepository<SqlStoredProcedure, Guid> repository,
        ISqlExecutorService sqlExecutorService) : base(repository)
    {
        _sqlExecutorService = sqlExecutorService;
    }

    public override async Task<SqlStoredProcedureDto> CreateAsync(CreateSqlStoredProcedureDto input)
    {
        var entity = new SqlStoredProcedure(
            GuidGenerator.Create(),
            input.ProcedureName,
            input.SchemaName ?? "dbo",
            input.DisplayName,
            input.ProcedureBody,
            input.DataSourceCode,
            CurrentTenant.Id)
        {
            Description = input.Description,
            Category = input.Category,
            Parameters = input.Parameters
        };

        await Repository.InsertAsync(entity);
        return ObjectMapper.Map<SqlStoredProcedure, SqlStoredProcedureDto>(entity);
    }

    public override async Task<SqlStoredProcedureDto> UpdateAsync(Guid id, UpdateSqlStoredProcedureDto input)
    {
        var entity = await Repository.GetAsync(id);

        entity.DisplayName = input.DisplayName;
        entity.Description = input.Description;
        entity.UpdateBody(input.ProcedureBody);
        entity.Category = input.Category;
        entity.Parameters = input.Parameters;

        await Repository.UpdateAsync(entity);
        return ObjectMapper.Map<SqlStoredProcedure, SqlStoredProcedureDto>(entity);
    }

    public async Task<SqlQueryExecutionResultDto> DeployAsync(DeployStoredProcedureDto input)
    {
        var procedure = await Repository.GetAsync(input.Id);

        // Drop if exists and requested
        if (input.DropIfExists)
        {
            await _sqlExecutorService.DropObjectAsync(
                procedure.ProcedureName,
                "SQL_STORED_PROCEDURE",
                procedure.DataSourceCode,
                procedure.SchemaName);
        }

        // Deploy the procedure
        var result = await _sqlExecutorService.DeployStoredProcedureAsync(
            procedure.ProcedureBody,
            procedure.DataSourceCode);

        if (result.Success)
        {
            procedure.MarkAsDeployed();
            await Repository.UpdateAsync(procedure);
        }

        return MapExecutionResult(result);
    }

    public async Task<bool> CheckExistsAsync(Guid id)
    {
        var procedure = await Repository.GetAsync(id);
        
        return await _sqlExecutorService.CheckObjectExistsAsync(
            procedure.ProcedureName,
            "SQL_STORED_PROCEDURE",
            procedure.DataSourceCode,
            procedure.SchemaName);
    }

    public async Task<SqlQueryExecutionResultDto> DropAsync(Guid id)
    {
        var procedure = await Repository.GetAsync(id);
        
        var result = await _sqlExecutorService.DropObjectAsync(
            procedure.ProcedureName,
            "SQL_STORED_PROCEDURE",
            procedure.DataSourceCode,
            procedure.SchemaName);

        if (result.Success)
        {
            procedure.IsDeployed = false;
            await Repository.UpdateAsync(procedure);
        }

        return MapExecutionResult(result);
    }

    private SqlQueryExecutionResultDto MapExecutionResult(SqlExecutionResult result)
    {
        return new SqlQueryExecutionResultDto
        {
            Success = result.Success,
            Message = result.Message,
            Data = result.Data,
            RowsAffected = result.RowsAffected,
            ExecutionTimeMs = result.ExecutionTimeMs,
            Metadata = result.Metadata
        };
    }
}