using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Sozsoft.Mcp.Dtos;
using Sozsoft.Mcp.Services;
using Sozsoft.Platform;
using Volo.Abp.Authorization.Permissions;

namespace Sozsoft.Mcp;

/// <summary>
/// Sema kesfini JSON veri sozlugu uzerinden karsilar; sozlugu okuma ve arama normalizasyonu
/// domain servisindedir (<see cref="IMcpSchemaDictionary"/>). Kullanici yalnizca uygulamada
/// okuma yetkisi olan listeleri gorur (<see cref="IMcpListFormAccessFilter"/>).
/// </summary>
[Authorize(PlatformConsts.AppCodes.DeveloperKits.McpServers.Invoke)]
public class McpSchemaAppService(
    IMcpServerConfigProvider serverConfigProvider,
    IMcpSchemaDictionary dictionary,
    IMcpListFormAccessFilter accessFilter,
    IPermissionChecker permissionChecker)
    : McpAppService(serverConfigProvider), IMcpSchemaAppService
{
    public async Task<McpServerConfigDto?> GetServerConfigAsync()
        => await ResolveServerConfigAsync();

    public async Task<List<string>> GetAvailableToolsAsync()
    {
        var config = await ResolveServerConfigAsync();
        var candidates = McpToolPolicy.VisibleTools(
            config is not null,
            config?.AllowWrite ?? false,
            config?.AllowedTools ?? []);

        var required = candidates
            .Where(McpToolNames.RequiredPermissions.ContainsKey)
            .Select(tool => McpToolNames.RequiredPermissions[tool])
            .Distinct(StringComparer.Ordinal)
            .ToArray();

        var granted = new HashSet<string>(StringComparer.Ordinal);
        if (required.Length > 0)
        {
            var grants = await permissionChecker.IsGrantedAsync(required);
            granted.UnionWith(grants.Result
                .Where(result => result.Value == PermissionGrantResult.Granted)
                .Select(result => result.Key));
        }

        return [.. candidates.Where(tool =>
            !McpToolNames.RequiredPermissions.TryGetValue(tool, out var permission) || granted.Contains(permission))];
    }

    public async Task<McpSchemaInfoDto> GetSchemaInfoAsync()
    {
        var snapshot = await dictionary.GetSnapshotAsync();
        if (snapshot is null)
        {
            return new McpSchemaInfoDto
            {
                Available = false,
                TenantName = dictionary.ResolveTenantName(),
                Message = L[McpErrorCodes.DictionaryNotFound, McpConsts.DictionaryProcedureName]
            };
        }

        return new McpSchemaInfoDto
        {
            Available = true,
            CacheKey = snapshot.CacheKey,
            RefreshedAt = snapshot.RefreshedAt,
            FormCount = snapshot.FormCount,
            FieldCount = snapshot.FieldCount,
            TenantName = snapshot.TenantName,
            DefinitionCultureName = snapshot.DefinitionCultureName,
            UiCultureName = snapshot.UiCultureName
        };
    }

    public async Task<List<McpListSummaryDto>> GetListsAsync(string? search = null, int maxResults = 200)
    {
        await EnsureToolAllowedAsync(McpToolNames.ListLists);

        var forms = await GetReadableListFormsAsync();
        var normalizedSearch = dictionary.Normalize(search);

        var matches = forms.Where(form => normalizedSearch.Length == 0
                                       || dictionary.Normalize(form.SearchText).Contains(normalizedSearch, StringComparison.Ordinal));

        return [.. matches.Take(NormalizeLimit(maxResults, 200)).Select(ToSummary)];
    }

    public async Task<McpListDetailDto?> GetListAsync(string listFormCode)
    {
        await EnsureToolAllowedAsync(McpToolNames.DescribeList);

        if (string.IsNullOrWhiteSpace(listFormCode))
        {
            return null;
        }

        var forms = await GetReadableListFormsAsync();
        var form = forms.FirstOrDefault(candidate =>
            string.Equals(candidate.ListFormCode, listFormCode, StringComparison.OrdinalIgnoreCase));

        if (form is null)
        {
            return null;
        }

        var detail = new McpListDetailDto();
        CopySummary(form, detail);
        detail.Columns = [.. (form.Fields ?? []).Select(ToColumn)];

        return detail;
    }

    public async Task<List<McpSchemaMatchDto>> SearchAsync(string term, int maxResults = 50)
    {
        await EnsureToolAllowedAsync(McpToolNames.SearchSchema);

        var normalized = dictionary.Normalize(term);
        if (normalized.Length == 0)
        {
            return [];
        }

        var limit = NormalizeLimit(maxResults, 50);
        var forms = await GetReadableListFormsAsync();
        var results = new List<McpSchemaMatchDto>();

        foreach (var form in forms)
        {
            var formMatches = dictionary.Normalize(form.SearchText).Contains(normalized, StringComparison.Ordinal);

            var columnMatches = (form.Fields ?? [])
                .Where(field => dictionary.Normalize(field.Field).Contains(normalized, StringComparison.Ordinal)
                             || dictionary.Normalize(field.DisplayName).Contains(normalized, StringComparison.Ordinal))
                .Select(ToColumn)
                .ToList();

            if (!formMatches && columnMatches.Count == 0)
            {
                continue;
            }

            results.Add(new McpSchemaMatchDto
            {
                ListFormCode = form.ListFormCode ?? string.Empty,
                DisplayName = form.DisplayName,
                TableName = NullIfEmpty(form.TableName),
                MatchedColumns = columnMatches
            });

            if (results.Count >= limit)
            {
                break;
            }
        }

        return results;
    }

    private async Task<List<McpDictionaryListForm>> GetReadableListFormsAsync()
    {
        var forms = await dictionary.GetListFormsAsync();
        var readable = await accessFilter.GetReadableListFormCodesAsync();

        return [.. forms.Where(form => form.ListFormCode is not null && readable.Contains(form.ListFormCode))];
    }

    private static McpListSummaryDto ToSummary(McpDictionaryListForm form)
    {
        var summary = new McpListSummaryDto();
        CopySummary(form, summary);

        return summary;
    }

    private static void CopySummary(McpDictionaryListForm form, McpListSummaryDto target)
    {
        target.ListFormCode = form.ListFormCode ?? string.Empty;
        target.DisplayName = NullIfEmpty(form.DisplayName);
        target.Title = NullIfEmpty(form.Title);
        target.Description = NullIfEmpty(form.Description);
        target.TableName = NullIfEmpty(form.TableName);
        target.SqlSourceName = NullIfEmpty(form.SqlSourceName);
        target.SourceKind = NullIfEmpty(form.SourceKind);
        target.KeyFieldName = NullIfEmpty(form.KeyFieldName);
        target.FieldCount = form.Fields?.Count ?? 0;
    }

    private static McpColumnDto ToColumn(McpDictionaryField field) => new()
    {
        Field = field.Field ?? string.Empty,
        DisplayName = NullIfEmpty(field.DisplayName),
        SqlDataType = NullIfEmpty(field.SqlDataType),
        IsVisible = field.IsVisible,
        IsBooleanColumn = field.IsBooleanColumn,
        LookupTableName = NullIfEmpty(field.LookupTableName),
        LookupValueColumn = NullIfEmpty(field.LookupValueColumn),
        LookupDisplayColumn = NullIfEmpty(field.LookupDisplayColumn),
        IsSensitive = field.IsSensitive,
        IsDefaultSelectColumn = field.IsDefaultSelectColumn
    };

    private static int NormalizeLimit(int requested, int fallback)
        => requested <= 0 ? fallback : Math.Min(requested, fallback * 5);

    private static string? NullIfEmpty(string? value)
        => string.IsNullOrWhiteSpace(value) ? null : value;
}