using SzCore.DataObjects;

namespace SzCore;

public class SzDataHandler
{
    private readonly Dictionary<string, SzDataset> _loadedDatasets = [];
    private readonly Dictionary<string, ISzTemplate> _loadedTemplates = [];

    public SzDataHandler() { }

    public void ClearCache()
    {
        _loadedDatasets.Clear();
        _loadedTemplates.Clear();
    }

    #region Datasets
    public async Task<SzResult<bool>> SaveDatasetAsync(SzDataset dataset, CancellationToken ct = default)
    {
        var datasetPath = Path.Combine(SZ.LocalFileManager.DatasetsPath, dataset.Id, "dataset.json");
        try
        {
            var json = SZ.Parser.SerializeDatasetToJson(dataset);
            var evalResult = await SZ.Evaluator.EvaluateDatasetAsync(dataset);
            if (!evalResult.IsSuccess) return SzResult<bool>.Failure($"Could not save dataset, evaluation failed: {evalResult.Error!}");
            var success = await SZ.LocalFileManager.SaveFileAsync(datasetPath, json, ct);
            return success ? SzResult<bool>.Success(true) : SzResult<bool>.Failure("Failed to write dataset file.");
        }
        catch (Exception e)
        {
            SZ.Logger.LogError("Error saving dataset: " + e.Message);
            return SzResult<bool>.Failure(e.Message);
        }
    }

    public async Task<SzResult<SzDataset>> LoadDatasetAsync(string datasetId, CancellationToken ct = default)
    {
        if (_loadedDatasets.TryGetValue(datasetId, out SzDataset? value))
            return SzResult<SzDataset>.Success(value);

        var datasetPath = Path.Combine(SZ.LocalFileManager.DatasetsPath, datasetId, "dataset.json");
        
        var json = await SZ.LocalFileManager.LoadFileAsync(datasetPath, ct);
        if (json is null) 
            return SzResult<SzDataset>.Failure($"Could not find dataset file for ID '{datasetId}'");

        var parsedDataset = SZ.Parser.DeserializeDataset(json);
        if (parsedDataset is null)
            return SzResult<SzDataset>.Failure($"Failed to parse dataset JSON for ID '{datasetId}'");

        _loadedDatasets.TryAdd(parsedDataset.Id, parsedDataset);
        return SzResult<SzDataset>.Success(parsedDataset);
    }

    public async Task<SzResult<bool>> DeleteDatasetAsync(string datasetId)
    {
        return await Task.Run(() => {
            try
            {
                var path = Path.Combine(SZ.LocalFileManager.DatasetsPath, datasetId);
                if (Directory.Exists(path)) Directory.Delete(path, true);
                _loadedDatasets.Remove(datasetId);
                return SzResult<bool>.Success(true);
            }
            catch (Exception e)
            {
                return SzResult<bool>.Failure(e.Message);
            }
        });
    }

    public async Task<SzResult<SzDataset>> CreateDatasetAsync(string name, string templateId, string version = "1_0", string? id = null)
    {
        if (string.IsNullOrEmpty(name)) return SzResult<SzDataset>.Failure("Name empty.");

        var templateResult = await LoadTemplateAsync<SzDataObjectTemplate>(templateId);
        if (!templateResult.IsSuccess || templateResult.Value is null)
            return SzResult<SzDataset>.Failure($"Template '{templateId}' not found.");

        var newDataset = new SzDataset()
        {
            Name = name,
            Id = id ?? name.ToLower().Replace(" ", "-").Trim() + "@" + version,
            DataObjectTemplateId = templateResult.Value.Id,
            DataObjectType = templateResult.Value.DataObjectType,
        };

        return SzResult<SzDataset>.Success(newDataset);
    }

    public async Task<SzResult<string>> GetFieldValueFromPath(string path)
    {

        var parts = path.Split('.');
        if (parts.Length < 3) return SzResult<string>.Failure("Not enough arguments in path");

        var datasetId = parts[0];
        var dataObjectId = parts[1];
        var fieldPath = string.Join(".", parts.Skip(2));

        if (!datasetId.Contains('@'))
        {
            SZ.Logger.LogWarning($"Trying to get a field value from dataset `{datasetId}` but no dataset version was specified. Attempting to fallback to version 1.0");
            datasetId += "@1_0";
        }

        var datasetResult = await LoadDatasetAsync(datasetId);
        if (!datasetResult.IsSuccess) 
            return SzResult<string>.Failure($"Could not get field value, dataset with id '{datasetId}' could not be loaded: {datasetResult.Error}");

        var dataset = datasetResult.Value;
        if (dataset is null) return SzResult<string>.Failure("Dataset was null somehow");

        if (!dataset.DataObjects.TryGetValue(dataObjectId, out var dataObject))
            return SzResult<string>.Failure($"Data object {dataObjectId} does not exist in dataset {datasetId}");

        if (!dataObject.Fields.TryGetValue(fieldPath, out var field))
            return SzResult<string>.Failure($"Field {fieldPath} does not exist in Data Object {dataObjectId}");

        return SzResult<string>.Success(field.Value);
        
    }
    #endregion

    #region Templates
    public async Task<SzResult<bool>> SaveTemplateAsync(ISzTemplate template, CancellationToken ct = default)
    {
        var templatePath = Path.Combine(SZ.LocalFileManager.TemplatesPath, template.Id, "template.json");
        try
        {
            var json = SZ.Parser.SerializeTemplateToJson(template);
            var success = await SZ.LocalFileManager.SaveFileAsync(templatePath, json, ct);
            return success ? SzResult<bool>.Success(true) : SzResult<bool>.Failure("Failed to write template file.");
        }
        catch (Exception e)
        {
            return SzResult<bool>.Failure(e.Message);
        }
    }

    public async Task<SzResult<T>> LoadTemplateAsync<T>(string templateId, CancellationToken ct = default) where T : ISzTemplate
    {
        if (_loadedTemplates.TryGetValue(templateId, out ISzTemplate? cachedTemplate))
            return SzResult<T>.Success((T)cachedTemplate);

        var path = Path.Combine(SZ.LocalFileManager.TemplatesPath, templateId, "template.json");
        var json = await SZ.LocalFileManager.LoadFileAsync(path, ct);
        
        if (json is null) return SzResult<T>.Failure($"Template '{templateId}' not found.");

        var parsed = SZ.Parser.DeserializeTemplate<T>(json);
        if (parsed is null) return SzResult<T>.Failure("Parse error.");

        _loadedTemplates.TryAdd(parsed.Id, parsed);
        return SzResult<T>.Success(parsed);
    }

    public async Task<SzResult<bool>> DeleteTemplateAsync(string templateId)
    {
        return await Task.Run(() => {
            try
            {
                var path = Path.Combine(SZ.LocalFileManager.TemplatesPath, templateId);
                if (Directory.Exists(path)) Directory.Delete(path, true);
                _loadedTemplates.Remove(templateId);
                return SzResult<bool>.Success(true);
            }
            catch (Exception e)
            {
                return SzResult<bool>.Failure(e.Message);
            }
        });
    }
    #endregion

    #region Synchronous Creation Logic
    public SzResult<SzTemplateField> CreateTemplateField(string id, SzFieldType fieldType, bool isList = false, string? defaultValue = null, bool isSpecialType = false, string? specialTypeValue = null)
    {
        if (string.IsNullOrEmpty(id)) return SzResult<SzTemplateField>.Failure("ID cannot be empty.");

        return SzResult<SzTemplateField>.Success(new SzTemplateField()
        {
            Id = id,
            FieldType = fieldType,
            IsList = isList,
            IsSpecialType = isSpecialType,
            DefaultValue = defaultValue ?? "",
            SpecialTypeValue = specialTypeValue ?? ""
        });
    }

    public SzResult<SzDataObjectTemplate> CreateDataObjectTemplate(string name, string dataObjectType, string version = "1_0", string? id = null, string? description = null, List<SzTemplateField>? fields = null)
    {
        var newTemplate = new SzDataObjectTemplate()
        {
            Name = name,
            Id = id ?? name.ToLower().Replace(" ", "-").Trim() + "@" + version,
            DataObjectType = dataObjectType,
            Description = description ?? ""
        };

        if (fields != null)
        {
            foreach (var field in fields) newTemplate.TemplateFields.TryAdd(field.Id, field);
        }

        return SzResult<SzDataObjectTemplate>.Success(newTemplate);
    }

    public SzResult<SzDataObject> CreateDataObject(SzDataObjectTemplate template, string name, string? id = null)
    {
        var dataObject = new SzDataObject()
        {
            Name = name,
            Id = id ?? name.ToLower().Replace(" ", "-").Trim()
        };

        var fieldsResult = CreateFieldsFromTemplate(template);
        if (!fieldsResult.IsSuccess) return SzResult<SzDataObject>.Failure(fieldsResult.Error!);
        
        dataObject.Fields = fieldsResult.Value!;
        return SzResult<SzDataObject>.Success(dataObject);
    }

    public SzResult<Dictionary<string, SzField>> CreateFieldsFromTemplate(ISzTemplate template)
    {
        var fields = new Dictionary<string, SzField>();
        foreach (var tempField in template.TemplateFields.Values)
        {
            fields.Add(tempField.Id, new SzField { Id = tempField.Id, FieldType = tempField.FieldType, IsList = tempField.IsList });
        }
        return SzResult<Dictionary<string, SzField>>.Success(fields);
    }
    #endregion

    #region Bulk Operations
    public async Task LoadAllDatasetsAsync(CancellationToken ct = default)
    {
        _loadedDatasets.Clear();
        if (!Directory.Exists(SZ.LocalFileManager.DatasetsPath)) return;

        var dirs = Directory.GetDirectories(SZ.LocalFileManager.DatasetsPath);
        foreach (var dir in dirs)
        {
            var id = Path.GetFileName(dir);
            await LoadDatasetAsync(id, ct);
        }
    }
    #endregion
}