using System;

namespace GitConverter.Lib.Models
{
    /// <summary>
    /// Represents the outcome of a conversion operation.
    /// </summary>
    /// <remarks>
    /// - Immutable value object intended to be returned from converter implementations and passed between layers.
    /// - Use the factory helpers <see cref="Success(string)"/> and <see cref="Failure(string)"/> to create instances.
    /// - Contains a timestamp (UTC) to help diagnostics and logging.
    /// - Implements <see cref="IEquatable{ConversionResult}"/> so callers can compare logical results.
    /// - Equality semantics:
    ///     - Two ConversionResult instances are considered equal when their <see cref="Status"/> and
    ///       normalized <see cref="Message"/> values are equal. The <see cref="TimestampUtc"/> is intentionally
    ///       excluded from equality because it represents creation time (diagnostic metadata) and not the logical
    ///       outcome of the conversion.
    /// - If you need TimestampUtc to be part of equality for a specific scenario, implement a comparer or extend
    ///   the type (for example ConversionResultWithMeta) rather than changing these semantics.
    /// </remarks>
    public sealed class ConversionResult : IEquatable<ConversionResult>
    {
        /// <summary>
        /// The status of the conversion.
        /// </summary>
        public ConversionStatus Status { get; }

        /// <summary>
        /// Human-friendly message describing the result. Empty string when not provided.
        /// Use this to surface concise diagnostics to CLI users or logs.
        /// </summary>
        public string Message { get; }

        /// <summary>
        /// UTC timestamp when the result instance was created.
        /// </summary>
        public DateTime TimestampUtc { get; }

        /// <summary>
        /// True when the conversion succeeded.
        /// </summary>
        public bool IsSuccess => Status == ConversionStatus.Success;

        private ConversionResult(ConversionStatus status, string message)
        {
            Status = status;
            Message = message ?? string.Empty;
            TimestampUtc = DateTime.UtcNow;
        }

        /// <summary>
        /// Create a success result with an optional message.
        /// </summary>
        public static ConversionResult Success(string message = null) =>
            new ConversionResult(ConversionStatus.Success, message);

        /// <summary>
        /// Create a failure result with an optional message describing the error.
        /// </summary>
        public static ConversionResult Failure(string message = null) =>
            new ConversionResult(ConversionStatus.Failure, message);

        /// <summary>
        /// Returns a compact textual representation useful for logs.
        /// </summary>
        public override string ToString() => $"{Status}: {Message}";

        /// <summary>
        /// Strongly-typed equality comparing logical result values.
        /// - Compares <see cref="Status"/> and <see cref="Message"/> (ordinal).
        /// - Does not consider <see cref="TimestampUtc"/> in equality.
        /// </summary>
        public bool Equals(ConversionResult other)
        {
            if (ReferenceEquals(null, other)) return false;
            if (ReferenceEquals(this, other)) return true;
            return Status == other.Status && string.Equals(Message, other.Message, StringComparison.Ordinal);
        }

        /// <summary>
        /// Object equality override delegates to strongly-typed equality.
        /// </summary>
        public override bool Equals(object obj) => Equals(obj as ConversionResult);

        /// <summary>
        /// Hash code based on the logical equality components.
        /// </summary>
        public override int GetHashCode()
        {
            unchecked
            {
                // combine Status and Message (ordinal) into hash
                int hash = 17;
                hash = hash * 31 + Status.GetHashCode();
                hash = hash * 31 + (Message != null ? StringComparer.Ordinal.GetHashCode(Message) : 0);
                return hash;
            }
        }

        /// <summary>
        /// Equality operator uses the same semantics as <see cref="Equals(ConversionResult)"/>.
        /// </summary>
        public static bool operator ==(ConversionResult left, ConversionResult right)
        {
            if (ReferenceEquals(left, right)) return true;
            if (ReferenceEquals(left, null)) return false;
            return left.Equals(right);
        }

        /// <summary>
        /// Inequality operator.
        /// </summary>
        public static bool operator !=(ConversionResult left, ConversionResult right) => !(left == right);
    }

    /// <summary>
    /// Status codes for <see cref="ConversionResult"/>.
    /// </summary>
    public enum ConversionStatus
    {
        /// <summary>Conversion completed successfully.</summary>
        Success = 0,
        /// <summary>Conversion failed (see <see cref="ConversionResult.Message"/> for details).</summary>
        Failure = 1
    }
}