using System.Threading;

namespace ParadoxSaveParser.Lib;

/// <summary>Thrown when a query cannot be compiled because it is malformed or uses unsupported syntax.</summary>
public class SearchExpressionException : Exception
{
    public SearchExpressionException(string message, ReadOnlySpan<char> part)
        : base($"{message}: '{part}'")
    {
    }
}

/// <summary>
///     A query such as <c>countries.*.technology</c>, and the expression tree compiled from it.
///     The tree is built on the first <see cref="Compile" /> and reused afterwards; only a change
///     of encoding touches it again, and then only to re-encode its literal keys.
/// </summary>
public class SearchExpressionCompilation
{
    private readonly string _query;

    // guards the tree while it is built or re-encoded, so parsers on several threads
    // can share one compilation
    private readonly Lock _compileLock = new();

    private ISearchExpression? _rootNode;
    private Encoding? _currentEncoding;

    /// <param name="query">Search query. Compiled on the first call to <see cref="Compile" />.</param>
    /// <exception cref="ArgumentException">the query is empty</exception>
    public SearchExpressionCompilation(string query)
    {
        ArgumentException.ThrowIfNullOrEmpty(query);
        _query = query;
    }

    /// <summary>
    ///     Returns the expression tree, with its literal keys encoded the way the save is.
    ///     Compiles the query on the first call, and re-encodes the tree when the encoding changes.
    /// </summary>
    /// <param name="encoding">Encoding of the strings inside the save being parsed.</param>
    /// <exception cref="SearchExpressionException">the query is malformed</exception>
    public ISearchExpression Compile(Encoding encoding)
    {
        lock (_compileLock)
        {
            if (_rootNode is null)
                _rootNode = CompilePart(_query, encoding, null);
            // keys are stored as bytes, so another encoding means encoding them again
            else if (!encoding.Equals(_currentEncoding)) 
                _rootNode.ReEncode(encoding);

            _currentEncoding = encoding;
            return _rootNode;
        }
    }

    /// <summary>True if <paramref name="chars" /> holds <paramref name="c" /> at
    /// <paramref name="i" /> as syntax, not as an escaped literal.</summary>
    private static bool CharEqualsAndNotEscaped(char c, ReadOnlySpan<char> chars, int i)
        // escaped if a backslash stands in either of the two preceding positions
        => chars[i] == c && (i < 1 || chars[i - 1] != '\\') && (i < 2 || chars[i - 2] != '\\');

    /// <summary>Compiles one path step together with everything that follows it.</summary>
    /// <param name="tail">
    ///     Step that continues the path after this one ends, or <c>null</c> if nothing follows.
    ///     Used for the part written after a group, as in <c>(a|b).c</c>, where every alternative
    ///     of the group continues with the same <c>.c</c>.
    /// </param>
    private static ISearchExpression CompilePart(ReadOnlySpan<char> query, Encoding encoding,
        ISearchExpression? tail)
    {
        // empty alternative, as in "(a||b)"
        if (query.IsEmpty)
            throw new SearchExpressionException("Empty expression", query);

        // "(a|b.c)" — a group of alternatives
        if (query[0] is '(')
            return CompileGroup(query, encoding, tail);

        // a plain step: find the '.' that ends it
        int partBeforePointLength = 0;
        while (partBeforePointLength < query.Length)
        {
            if (CharEqualsAndNotEscaped('.', query, partBeforePointLength))
                break;
            partBeforePointLength++;
        }

        // this step, and the rest of the path that becomes its child expression
        var part = query.Slice(0, partBeforePointLength);
        // empty step, as in "a..b" or ".b"
        if (part.IsEmpty)
            throw new SearchExpressionException("Empty path step", query);

        ReadOnlySpan<char> remaining = default;
        if (partBeforePointLength < query.Length)
        {
            remaining = query.Slice(partBeforePointLength + 1);
            if (remaining.IsEmpty)
                throw new SearchExpressionException("Path ends with '.'", query);
        }

        // when nothing follows this step, the path continues with the tail, which may be null too
        var next = remaining.IsEmpty ? tail : CompilePart(remaining, encoding, tail);

        // "*" — any node at this level
        if (part is "*")
            return new AnyMatchExpression(next);
        // "~" — nothing at this level
        if (part is "~")
            return NoMatchExpression.Instance;

        // a '*' anywhere else would be a wildcard inside a key
        for (int j = 0; j < part.Length; j++)
            if (CharEqualsAndNotEscaped('*', part, j))
                throw new SearchExpressionException("Pattern matching other than '*' is not supported", part);

        // "[7]" — match by position
        if (part[0] is '[')
        {
            if (part[^1] is not ']')
                throw new SearchExpressionException("Index step has no closing ']'", part);
            // strip the brackets
            var indexText = part.Slice(1, part.Length - 2);
            if (!int.TryParse(indexText, out int index) || index < 0)
                throw new SearchExpressionException("Index must be a non-negative number", part);
            return new IndexMatchExpression(index, next);
        }

        // an ordinary key
        return new ExactMatchExpression(part.ToString(), encoding, next);
    }

    /// <summary>Compiles "(a|b)", and the path written after it, if there is one.</summary>
    private static ISearchExpression CompileGroup(ReadOnlySpan<char> query, Encoding encoding,
        ISearchExpression? tail)
    {
        int close = FindGroupEnd(query);

        // "(a|b).c" — what stands after the group continues every alternative of it
        var afterGroup = query.Slice(close + 1);
        if (!afterGroup.IsEmpty)
        {
            if (CharEqualsAndNotEscaped(')', afterGroup, 0))
                throw new SearchExpressionException("Too many closing brackets", query);
            if (!CharEqualsAndNotEscaped('.', afterGroup, 0))
                throw new SearchExpressionException("Group must be followed by '.'", query);

            var rest = afterGroup.Slice(1);
            if (rest.IsEmpty)
                throw new SearchExpressionException("Path ends with '.'", query);
            tail = CompilePart(rest, encoding, tail);
        }

        // cut the group into alternatives and compile each of them with that same tail
        var subExprs = new List<ISearchExpression>();
        int begin = 1;
        int depth = 0;
        for (int i = 1; i < close; i++)
        {
            if (CharEqualsAndNotEscaped('(', query, i))
                depth++;
            else if (CharEqualsAndNotEscaped(')', query, i))
                depth--;
            // a deeper '|' belongs to a nested group and is compiled with it
            else if (depth == 0 && CharEqualsAndNotEscaped('|', query, i))
            {
                subExprs.Add(CompilePart(query.Slice(begin, i - begin), encoding, tail));
                begin = i + 1;
            }
        }

        // the last alternative has no '|' after it
        subExprs.Add(CompilePart(query.Slice(begin, close - begin), encoding, tail));
        return new MultipleMatchExpression(subExprs);
    }

    /// <summary>Finds the ')' that closes the group opened by the first character.</summary>
    private static int FindGroupEnd(ReadOnlySpan<char> query)
    {
        int depth = 0;
        for (int i = 0; i < query.Length; i++)
        {
            if (CharEqualsAndNotEscaped('(', query, i))
                depth++;
            else if (CharEqualsAndNotEscaped(')', query, i))
            {
                depth--;
                if (depth == 0)
                    return i;
            }
        }

        throw new SearchExpressionException("Too many opening brackets", query);
    }
}