using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.IO;

namespace GitConverter.Lib.Converters
{
    /// <summary>
    /// Helper that detects the specific JSON GIS format for a given JSON payload or file.
    /// </summary>
    /// <remarks>
    /// <para>
    /// <c>JsonFormatDetector</c> provides heuristic detection for a small set of common JSON-based
    /// GIS formats. Detection is based on top-level JSON structure and property names and is
    /// intentionally conservative: when detection is ambiguous the detector returns
    /// <see cref="Format.Unknown"/> rather than guessing.
    /// </para>
    /// <para>
    /// Supported format detections:
    /// - <c>GeoJson</c>: JSON objects where <c>"type" : "FeatureCollection"</c> or similar
    ///   GeoJSON structures are present.
    /// - <c>EsriJson</c>: Esri JSON feature sets often include both <c>"features"</c> and
    ///   <c>"spatialReference"</c> properties; the detector recognizes the common variants.
    /// - <c>GeoJsonSeq</c>: Newline-delimited GeoJSON (NDJSON/JSON sequence) or a top-level JSON
    ///   array of GeoJSON objects. The detector probes the first non-empty line when a full
    ///   document parse fails to support NDJSON detection.
    /// - <c>TopoJson</c>: TopoJSON documents identified by <c>"type":"Topology"</c>.
    /// </para>
    /// <para>
    /// Design notes and limitations:
    /// - The detector uses Newtonsoft.Json (Json.NET) and parses the provided payload into a
    ///   <see cref="JToken"/>. For very large files or streaming scenarios callers should perform
    ///   their own streaming-based sniffing rather than passing large payloads to these helpers.
    /// - Property name checks are case-insensitive. The detector does not perform deep content
    ///   validation beyond presence checks and the top-level <c>type</c> value.
    /// - NDJSON detection is heuristic: when full-document parsing throws a <see cref="JsonReaderException"/>,
    ///   the detector attempts to parse the first non-empty line as a JSON value and treats a
    ///   successful parse as evidence of GeoJSON sequence input.
    /// - Ambiguous inputs (for example JSON objects containing both GeoJSON and Esri-like keys in
    ///   unusual combinations) will produce <c>Format.Unknown</c>. Use explicit format options when
    ///   reliable conversion behavior is required.
    /// </para>
    /// <para>
    /// Thread-safety: the methods in this static helper are stateless and safe for concurrent use.
    /// </para>
    /// </remarks>
    public static class JsonFormatDetector
    {
        /// <summary>
        /// Enumeration of detected JSON GIS formats.
        /// </summary>
        public enum Format
        {
            Unknown = 0,
            GeoJson,
            EsriJson,
            GeoJsonSeq,
            TopoJson
        }

        /// <summary>
        /// Detect format from a JSON file. Throws on IO or parse errors.
        /// </summary>
        /// <param name="filePath">Path to the JSON file to inspect.</param>
        /// <returns>The detected <see cref="Format"/>. Returns <see cref="Format.Unknown"/> when
        /// the content cannot be classified.</returns>
        /// <remarks>
        /// <para>
        /// This method reads the entire file into memory via <see cref="File.ReadAllText(string)"/>
        /// and calls <see cref="DetectFromString(string)"/>. It will throw exceptions originating
        /// from file I/O or JSON parsing to the caller; callers that prefer a non-throwing API should
        /// use <see cref="TryDetectFromFile(string, out Format)"/>.
        /// </para>
        /// <para>
        /// Example usage:
        /// <code>
        /// var fmt = JsonFormatDetector.DetectFromFile("data.geojson");
        /// if (fmt == JsonFormatDetector.Format.GeoJson) { /* handle GeoJSON */ }
        /// </code>
        /// </para>
        /// </remarks>
        public static Format DetectFromFile(string filePath)
        {
            if (string.IsNullOrWhiteSpace(filePath)) throw new ArgumentNullException(nameof(filePath));
            var text = File.ReadAllText(filePath);
            return DetectFromString(text);
        }

        /// <summary>
        /// Non-throwing variant that attempts to detect format from a JSON file.
        /// </summary>
        /// <param name="filePath">Path to the JSON file to inspect.</param>
        /// <param name="result">When the method returns true this contains the detected format (may be <see cref="Format.Unknown"/>).</param>
        /// <returns>True when detection ran without unhandled exceptions; false when file access or parsing failed.</returns>
        /// <remarks>
        /// Use this method when calling code must avoid exceptions. The method returns <c>false</c>
        /// when the file does not exist, the path is invalid, or an unexpected parsing error occurs.
        /// When it returns <c>true</c> the <paramref name="result"/> value contains the detection
        /// outcome which may still be <see cref="Format.Unknown"/>.
        /// </remarks>
        public static bool TryDetectFromFile(string filePath, out Format result)
        {
            result = Format.Unknown;
            try
            {
                if (string.IsNullOrWhiteSpace(filePath)) return false;
                if (!File.Exists(filePath)) return false;
                var text = File.ReadAllText(filePath);
                result = DetectFromString(text);
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// Detect format from a JSON string payload.
        /// </summary>
        /// <param name="json">String containing JSON content; may represent an object, array or NDJSON.</param>
        /// <returns>The detected <see cref="Format"/> value. Returns <see cref="Format.Unknown"/> when the
        /// input cannot be classified.</returns>
        /// <remarks>
        /// <para>
        /// The detection strategy:
        /// - Attempt to parse the entire payload into a <see cref="JToken"/>. This supports arrays and
        ///   objects.
        /// - If parsing fails with <see cref="JsonReaderException"/>, probe the first non-empty line
        ///   and attempt to parse it; a successful parse is treated as a newline-delimited JSON (NDJSON)
        ///   sequence and reported as <see cref="Format.GeoJsonSeq"/>.
        /// - When a <see cref="JToken"/> is available, inspect its type and top-level properties:
        ///   - Top-level arrays -> <see cref="Format.GeoJsonSeq"/>.
        ///   - Objects: check top-level <c>type</c> property for <c>"Topology"</c> (TopoJSON) or
        ///     <c>"FeatureCollection"</c> (GeoJSON). Also check for presence of both
        ///     <c>"features"</c> and <c>"spatialReference"</c> to detect Esri JSON.
        /// - The method performs case-insensitive checks for property names and values.
        /// </para>
        /// <para>
        /// Performance considerations: this method parses the provided string into a DOM-style JSON
        /// representation which may be memory intensive for large payloads. For large files prefer
        /// streaming or line-based sniffing prior to calling this helper.
        /// </para>
        /// </remarks>
        public static Format DetectFromString(string json)
        {
            if (string.IsNullOrWhiteSpace(json)) return Format.Unknown;

            // Try parse as JToken to handle arrays and objects.
            JToken token;
            bool ndjsonProbe = false;
            try
            {
                token = JToken.Parse(json);
            }
            catch (JsonReaderException)
            {
                // Could be NDJSON (newline-delimited JSON). Try to detect by reading first non-empty line.
                var firstLine = ReadFirstNonEmptyLine(json);
                if (firstLine != null)
                {
                    try
                    {
                        token = JToken.Parse(firstLine);
                        // If we successfully parsed the first line of a non-JSON-root document, treat as NDJSON -> GeoJsonSeq.
                        ndjsonProbe = true;
                    }
                    catch
                    {
                        return Format.Unknown;
                    }
                }
                else
                {
                    return Format.Unknown;
                }
            }

            // If we discovered this by probing the first line of NDJSON, consider it a GeoJsonSeq.
            if (ndjsonProbe)
            {
                return Format.GeoJsonSeq;
            }

            // GeoJsonSeq: top-level array of GeoJSON objects
            if (token.Type == JTokenType.Array)
            {
                return Format.GeoJsonSeq;
            }

            if (token.Type != JTokenType.Object)
            {
                return Format.Unknown;
            }

            var obj = (JObject)token;

            // Scan all top-level properties once and exit early on a decisive match.
            bool hasFeatures = false;
            bool hasSpatialRef = false;
            string typeValue = null;

            foreach (var prop in obj.Properties())
            {
                var name = prop.Name;

                if (string.Equals(name, "type", StringComparison.OrdinalIgnoreCase))
                {
                    typeValue = prop.Value?.ToString();

                    // Immediate recognition for TopoJSON or GeoJSON FeatureCollection
                    if (!string.IsNullOrEmpty(typeValue))
                    {
                        if (string.Equals(typeValue, "Topology", StringComparison.OrdinalIgnoreCase))
                            return Format.TopoJson;

                        if (string.Equals(typeValue, "FeatureCollection", StringComparison.OrdinalIgnoreCase))
                            return Format.GeoJson;
                    }
                }
                else if (string.Equals(name, "features", StringComparison.OrdinalIgnoreCase))
                {
                    hasFeatures = true;
                    if (hasSpatialRef)
                        return Format.EsriJson; // both present -> Esri JSON
                }
                else if (string.Equals(name, "spatialReference", StringComparison.OrdinalIgnoreCase))
                {
                    hasSpatialRef = true;
                    if (hasFeatures)
                        return Format.EsriJson; // both present -> Esri JSON
                }

                // continue scanning other properties until a decisive match occurs
            }

            // If we saw features but no spatialReference, treat as EsriJson (common variant)
            if (hasFeatures)
                return Format.EsriJson;

            return Format.Unknown;
        }

        /// <summary>
        /// Return the first non-empty line from the provided text (used to sniff NDJSON).
        /// </summary>
        /// <param name="text">Input text to search for a non-empty line.</param>
        /// <returns>The first non-empty line, or <c>null</c> when none found.</returns>
        /// <remarks>
        /// The helper enumerates lines using a <see cref="StringReader"/> and returns the first
        /// line that contains non-whitespace characters. It is used as a lightweight probe when
        /// full-document parsing fails and NDJSON-like input is suspected.
        /// </remarks>
        private static string ReadFirstNonEmptyLine(string text)
        {
            using (var sr = new StringReader(text))
            {
                string line;
                while ((line = sr.ReadLine()) != null)
                {
                    if (!string.IsNullOrWhiteSpace(line))
                        return line;
                }
            }
            return null;
        }
    }
}