// SzfObject.cs

using System;
using System.Collections.Generic;

namespace SessionZero.Data;

public abstract class SzfObject
{
    public Guid Id { get; set; } = Guid.NewGuid();
    public string Name { get; set; } = string.Empty;
    public string Version { get; set; } = "1.0.0";
    public string Description { get; set; } = string.Empty;
    public string Author { get; set; } = string.Empty;
    public DateTime CreatedDate { get; set; } = DateTime.UtcNow;
    public DateTime ModifiedDate { get; set; } = DateTime.UtcNow;

    public string SchemaVersion { get; set; } = "1.0.0";
    public Dictionary<string, object> ExtendedMetadata { get; set; } = new();

    public abstract SzfObjectType ObjectType { get; }

    /// <summary>
    /// Abstract method for SzfObjects to parse their specific sections from the raw parsed structure.
    /// This promotes separation of concerns by moving type-specific parsing logic into the SzfObject itself.
    /// </summary>
    /// <param name="sections">A list of all parsed sections from the SZF file.</param>
    public abstract void ParseSections(List<SzfSection> sections);

    /// <summary>
    /// Virtual method for SzfObjects to generate their specific metadata fields.
    /// Override this in derived classes to add custom metadata to the [Metadata] section.
    /// </summary>
    /// <param name="writer">The SzfFieldWriter instance to write fields.</param>
    public virtual void GenerateMetadata(SzfFieldWriter writer)
    {
        // Default implementation does nothing, derived classes can override.
    }

    /// <summary>
    /// Virtual method for SzfObjects to generate their specific content sections.
    /// Override this in derived classes to add custom sections and fields.
    /// </summary>
    /// <param name="writer">The SzfFieldWriter instance to write fields and manage sections.</param>
    public virtual void GenerateContent(SzfFieldWriter writer)
    {
        // Default implementation does nothing, derived classes can override.
    }

    public virtual SzfValidationResult Validate()
    {
        var result = new SzfValidationResult { IsValid = true };

        if (string.IsNullOrWhiteSpace(Name))
            result.AddError("Name is required");

        if (Id == Guid.Empty)
            result.AddError("Valid GUID is required");

        if (!IsValidSemanticVersion(Version))
            result.AddError($"Invalid version format: {Version}");

        return result;
    }

    /// <summary>
    /// Parse SZF content and auto-detect the type
    /// </summary>
    public static SzfObject ParseFromSzf(string szfContent)
    {
        var parser = new SzfParser();
        return parser.Parse(szfContent);
    }

    /// <summary>
    /// Parse SZF content into a specific type
    /// </summary>
    public static T ParseFromSzf<T>(string szfContent) where T : SzfObject
    {
        var parser = new SzfParser();
        return parser.Parse<T>(szfContent);
    }

    public virtual string ToSzfString()
    {
        var generator = new SzfGenerator();
        return generator.Generate(this);
    }

    public virtual void PopulateFromMetadata(Dictionary<string, SzfField> metadata)
    {
        if (metadata.TryGetValue("Name", out var nameField))
            Name = nameField.Value?.ToString() ?? string.Empty;

        if (metadata.TryGetValue("Version", out var versionField))
            Version = versionField.Value?.ToString() ?? "1.0.0";

        if (metadata.TryGetValue("GUID", out var guidField) &&
            Guid.TryParse(guidField.Value?.ToString(), out var guid))
            Id = guid;

        if (metadata.TryGetValue("Author", out var authorField))
            Author = authorField.Value?.ToString() ?? string.Empty;

        if (metadata.TryGetValue("Description", out var descField))
            Description = descField.Value?.ToString() ?? string.Empty;
    }

    private static bool IsValidSemanticVersion(string version)
    {
        return System.Text.RegularExpressions.Regex.IsMatch(
            version, @"^\d+\.\d+\.\d+$");
    }
}

public enum SzfObjectType
{
    Dataset,
    CharacterTemplate,
    Character,
    Session
}

public class SzfValidationResult
{
    public bool IsValid { get; set; } = true;
    public List<string> Errors { get; set; } = [];
    public List<string> Warnings { get; set; } = [];

    public void AddError(string error)
    {
        Errors.Add(error);
        IsValid = false;
    }

    public void AddWarning(string warning)
    {
        Warnings.Add(warning);
    }
}

public class SzfField
{
    public string Name { get; set; } = string.Empty;
    public string Type { get; set; } = string.Empty;
    public object? Value { get; set; }
}