sessionzero-cs/SzCore/SzDataHandler.cs

using System.ComponentModel.Design;
using SzCore.DataObjects;

namespace SzCore;

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

    public SzDataHandler(){}

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

    #region Datasets
    public SzResult<bool> SaveDataset(SzDataset dataset)
    {
        var datasetPath = Path.Combine(SZ.LocalFileManager.DatasetsPath, dataset.Id, "dataset.json");
        try
        {
            var success = SZ.LocalFileManager.SaveFile(datasetPath, SZ.Parser.SerializeDatasetToJson(dataset));
            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 SzResult<bool> DeleteDataset(string datasetId)
    {
        try
        {
            Directory.Delete(Path.Combine(SZ.LocalFileManager.DatasetsPath, datasetId), true);
            return SzResult<bool>.Success(true);
        }
        catch (Exception e)
        {
            SZ.Logger.LogError($"Could not delete Dataset with id '{datasetId}': {e.Message}");
            return SzResult<bool>.Failure(e.Message);
        }
    }

    public SzResult<SzDataset> LoadDataset(string datasetId)
    {
        if (_loadedDatasets.TryGetValue(datasetId, out SzDataset? value))
        {
            return SzResult<SzDataset>.Success(value);
        }

        var datasetPath = Path.Combine(SZ.LocalFileManager.DataPath, "datasets", datasetId, "dataset.json");
        
        var json = SZ.LocalFileManager.LoadFile(datasetPath);
        if (json is null) 
        {
            SZ.Logger.LogWarning($"Could not load dataset with ID '{datasetId}'");
            return SzResult<SzDataset>.Failure($"Could not find dataset file for ID '{datasetId}'");  
        }

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

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

    public SzResult<SzDataset> CreateDataset(string name, string templateId, string? id = null, Guid? templateUuid = null)
    {
        if (string.IsNullOrEmpty(name))
            return SzResult<SzDataset>.Failure("Dataset name cannot be empty.");

        var templateResult = LoadTemplate<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(),
            DataObjectTemplateId = templateResult.Value.Id,
            DataObjectTemplateUuid = templateUuid,
            DataObjectType = templateResult.Value.DataObjectType,
            Uuid = Guid.NewGuid()
        };
        
        

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

    #region Templates
    public SzResult<bool> SaveTemplate(ISzTemplate template)
    {
        var templatePath = Path.Combine(SZ.LocalFileManager.TemplatesPath, template.Id, "template.json");
        try
        {
            var success = SZ.LocalFileManager.SaveFile(templatePath, SZ.Parser.SerializeTemplateToJson(template));
            return success ? SzResult<bool>.Success(true) : SzResult<bool>.Failure("Failed to write template file.");
        }
        catch (Exception e)
        {
            SZ.Logger.LogError("Error saving template: " + e.Message);
            return SzResult<bool>.Failure(e.Message);
        }
    }

    public SzResult<bool> DeleteTemplate(string templateId)
    {
        try
        {
            Directory.Delete(Path.Combine(SZ.LocalFileManager.TemplatesPath, templateId), true);
            return SzResult<bool>.Success(true);
        }
        catch (Exception e)
        {
            SZ.Logger.LogError($"Could not delete Template with id '{templateId}': {e.Message}");
            return SzResult<bool>.Failure(e.Message);
        }
    }

    public SzResult<T> LoadTemplate<T>(string templateId) where T : ISzTemplate
    {
        if (_loadedTemplates.TryGetValue(templateId, out ISzTemplate? cachedTemplate))
        {
            return SzResult<T>.Success((T)cachedTemplate);
        }

        var templatePah = Path.Combine(SZ.LocalFileManager.TemplatesPath, templateId, "template.json");
        
        var json = SZ.LocalFileManager.LoadFile(templatePah);
        if (json is null) 
        {
            SZ.Logger.LogWarning($"Could not load template with ID '{templateId}'");
            return SzResult<T>.Failure($"Could not find template file for ID '{templateId}'");  
        }

        var parsedTemplate = SZ.Parser.DeserializeTemplate<T>(json);
        if (parsedTemplate is null)
        {
            SZ.Logger.LogWarning($"Could not load template with ID '{templateId}'");
            return SzResult<T>.Failure($"Failed to parse template JSON for ID '{templateId}'");  
        }

        _loadedTemplates.TryAdd(parsedTemplate.Id, parsedTemplate);

        return SzResult<T>.Success(parsedTemplate);
    }

    public SzResult<SzDataObjectTemplate> CreateDataObjectTemplate(string name, string dataObjectType, string? id = null, string? description = null, List<SzTemplateField>? fields = null)
    {
        if (string.IsNullOrEmpty(name)) return SzResult<SzDataObjectTemplate>.Failure("Name cannot be empty.");
        if (string.IsNullOrEmpty(dataObjectType)) return SzResult<SzDataObjectTemplate>.Failure("DataObjectType cannot be empty.");

        var newTemplate = new SzDataObjectTemplate()
        {
            Name = name,
            Id = id ?? name.ToLower().Replace(" ", "-").Trim(),
            DataObjectType = dataObjectType,
            Uuid = Guid.NewGuid(),
            Description = description ?? ""
        };

        if (fields is null) return SzResult<SzDataObjectTemplate>.Success(newTemplate);
        foreach (var field in fields)
        {
            newTemplate.TemplateFields.Add(field.Id, field);    
        }

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

    #region Other
    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.");

        var newField = new SzTemplateField()
        {
            Id = id,
            FieldType = fieldType,
            IsList = isList,
            IsSpecialType = isSpecialType,
            DefaultValue = defaultValue ?? "",
            SpecialTypeValue = specialTypeValue ?? ""
        };

        return SzResult<SzTemplateField>.Success(newField);
    }

    public SzResult<SzField> CreateField(string id, SzFieldType fieldType, bool isList = false, string? value = null)
    {
        if (string.IsNullOrEmpty(id))
            return SzResult<SzField>.Failure("Could not create field, the id parameter was empty");
        
        var newField = new SzField()
        {
            Id = id,
            FieldType = fieldType,
            IsList = isList,
            Value = value ?? ""
        };

        return SzResult<SzField>.Success(newField);
    }

    public SzResult<Dictionary<string, SzField>> CreateFieldsFromTemplate(ISzTemplate template)
    {
        var fields = new Dictionary<string, SzField>();
        foreach (var tempField in template.TemplateFields.Values)
        {
            var newField = CreateField(tempField.Id, tempField.FieldType, tempField.IsList);
            if (!newField.IsSuccess || newField.Value is null)
                return SzResult<Dictionary<string, SzField>>.Failure($"Could not create field: {newField.Error}");
            fields.Add(newField.Value.Id, newField.Value);
        }

        return SzResult<Dictionary<string, SzField>>.Success(fields);
    }

    public SzResult<SzDataObject> CreateDataObject(SzDataObjectTemplate template, string name, string? id = null)
    {
        if (string.IsNullOrEmpty(name))
            return SzResult<SzDataObject>.Failure("Could not create object, name was empty");
        
        var dataObject = new SzDataObject()
        {
            Name = name,
            Id = id ?? name.ToLower().Replace(" ", "-").Trim()
        };

        var createFieldsResult = CreateFieldsFromTemplate(template);
        if (!createFieldsResult.IsSuccess || createFieldsResult.Value is null)
            return SzResult<SzDataObject>.Failure($"Could not create data object's fields: {createFieldsResult.Error}");
        dataObject.Fields = createFieldsResult.Value;
        
        return SzResult<SzDataObject>.Success(dataObject);
    }
    #endregion

    #region Tests
    private void LoadAllDatasets()
    {
        _loadedDatasets.Clear();
        if (!Directory.Exists(SZ.LocalFileManager.DatasetsPath))
        {
            throw new Exception("Could not load datasets, the dataset directory does not exist.");
        }

        foreach (var dir in Directory.GetDirectories(SZ.LocalFileManager.DatasetsPath))
        {
            var datasetFilePath = Path.Combine(dir, "dataset.json");
            if (!File.Exists(datasetFilePath)) continue;

            var datasetJson = SZ.LocalFileManager.LoadFile(datasetFilePath);
            if (datasetJson == null) continue;

            var parsedDataset = SZ.Parser.DeserializeDataset(datasetJson);
            if (parsedDataset == null)
            {
                SZ.Logger.LogWarning($"Parse error: Could not parse file {datasetFilePath} as an SzDataset");
                continue;
            }

            _loadedDatasets.Add(parsedDataset.Id, parsedDataset);
        }
    }

    private void LoadAllTemplates()
    {
        _loadedTemplates.Clear();
        if (!Directory.Exists(SZ.LocalFileManager.TemplatesPath))
        {
            throw new Exception("Could not load templates, the template directory does not exist.");
        }

        foreach (var dir in Directory.GetDirectories(SZ.LocalFileManager.TemplatesPath))
        {
            var templateFilePath = Path.Combine(dir, "template.json");
            if (!File.Exists(templateFilePath)) continue;

            var templateJson = SZ.LocalFileManager.LoadFile(templateFilePath);
            if (templateJson == null) continue;

            var parsedTemplate = SZ.Parser.DeserializeTemplate<ISzTemplate>(templateJson);
            if (parsedTemplate == null)
            {
                SZ.Logger.LogWarning($"Parse error: Could not parse file {templateFilePath} as an ISzTemplate");
                continue;
            }

            _loadedTemplates.Add(parsedTemplate.Id, parsedTemplate);
        }
    }
    #endregion
}