using System.Data;
using System.Text;
using SzCore.DataObjects;

namespace SzCore;

public class SzEvaluator
{

    public SzOperationResult EvaluateDataset(SzDataset dataset)
    {
        if (dataset is null) return new SzOperationResult(false, "Dataset cannot be null");

        var errors = new StringBuilder();

        var template = SZ.SzDataHandler.LoadTemplate<SzDataObjectTemplate>(dataset.DataObjectTemplateId);
        if (template is null) return new SzOperationResult(false, $"Template with id {dataset.DataObjectTemplateId} for Dataset ID {dataset.Id} could not be loaded");

        foreach (var dataObject in dataset.DataObjects.Values)
        {
            var evalResult = EvaluateDataObject(dataObject, template);
            if (!evalResult.Pass) errors.Append(evalResult.Errors);
        }

        var errString = errors.ToString();
        return new SzOperationResult(string.IsNullOrEmpty(errString), errString);
    }

    public SzOperationResult EvaluateDataObject(SzDataObject dataObject, SzDataObjectTemplate template)
    {
        if (dataObject is null || template is null) return new SzOperationResult(false, "dataObject or template is null");

        var errors = new StringBuilder();

        foreach (var (key, templateField) in template.TemplateFields)
        {
            if (!dataObject.Fields.TryGetValue(key, out var matchingField))
            {
                errors.AppendLine($"Missing required field: '{key}'");
                continue;
            }

            var templateMatchResult = DoesFieldMatchTemplateField(matchingField, templateField);
            if (!templateMatchResult.Pass) errors.Append(templateMatchResult.Errors);

            var evalResult = EvaluateFieldValue(matchingField);
            if (!evalResult.Pass) errors.Append(evalResult.Errors);
        }

        foreach (var objectFieldKey in dataObject.Fields.Keys)
        {
            if (!template.TemplateFields.ContainsKey(objectFieldKey))
            {
                errors.AppendLine($"DataObject contains extra field '{objectFieldKey}' not found in template");
            }
        }

        var errString = errors.ToString().Trim();
        return new SzOperationResult(string.IsNullOrEmpty(errString), string.IsNullOrEmpty(errString) ? "" : errString);
    }

    public SzOperationResult DoesFieldMatchTemplateField(SzField field, SzTemplateField templateField)
    {
        var errors = new StringBuilder();

        if (field.Id != templateField.Id) errors.AppendLine($"Field ID mismatch for '{field.Id}': Expected {templateField.Id}");
        if (field.FieldType != templateField.FieldType) errors.AppendLine($"Field '{field.Id}' type mismatch: Expected {templateField.FieldType}, got {field.FieldType}");
        if (field.IsList != templateField.IsList) errors.AppendLine($"Field '{field.Id}' IsList mismatch: Expected {templateField.IsList}");

        var errString = errors.ToString().Trim();
        return new SzOperationResult(string.IsNullOrEmpty(errString), errString);
    }

    public SzOperationResult EvaluateFieldValue(SzField field)
    {
        if (string.IsNullOrWhiteSpace(field.Value)) 
            return new SzOperationResult(true, "");

        var errors = new StringBuilder(); 

        switch (field.FieldType)
        {
            case SzFieldType.Text: 
                break;

            case SzFieldType.Number:
                if (!float.TryParse(field.Value, out _))
                {
                    errors.AppendLine($"Value '{field.Value}' in field '{field.Id}' is not a valid Number");
                }
                break;
                
            case SzFieldType.Bool:
                if (!bool.TryParse(field.Value, out _))
                {
                    errors.AppendLine($"Value '{field.Value}' in field '{field.Id}' is not a valid Boolean");
                }
                break;

            case SzFieldType.Formula:
                errors.AppendLine($"Formula field type is not implemented yet. Field: {field.Id}");
                break;

            case SzFieldType.Reference:
                errors.AppendLine($"Reference field type is not implemented yet. Field: {field.Id}");
                break;

            default: 
                errors.AppendLine($"Unsupported FieldType '{field.FieldType}' for field '{field.Id}'");
                break;
        }

        var errString = errors.ToString().Trim();
        return new SzOperationResult(string.IsNullOrEmpty(errString), errString);
    }
}