//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ExpSchemaSource"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. All rights reserved.
//     
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//     
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
using StgSharp.Collections;
using StgSharp.Graphics.OpenGL;

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.Tracing;
using System.Text;
using System.Text.RegularExpressions;

namespace StgSharp.Script.Express
{
    public partial class ExpSchemaSource
    {

        private static Regex 
            _constDefineBegin = GetConstDefineBegin(),
            _constDefineEnd = GetConstDefineEnd(),
            _schemaBegin = GetSchemaBegin(),
            _schemaEnd = GetSchemaEnd(),
            _entityDefineBegin = GetEntityDefineBegin(),
            _entityDefineEnd = GetEntityDefineEnd(),
            _typeDefineBegin = GetTypeDefineBegin(),
            _typeDefineEnd = GetTypeDefineEnd(),
            _functionDefineBegin = GetFunctionDefineBegin(),
            _functionDefineEnd = GetFunctionDefineEnd(),
            _ruleDefineBegin = GetRuleDefineBegin(),
            _ruleDefineEnd = GetRuleDefineEnd();

        private readonly GeneratedExpSchema _compileResult = new GeneratedExpSchema();

        private List<IExpElementSource> _sourceCache = [];

        private string name;

        public ExpSchemaSource() { }

        public List<IExpElementSource> Cache
        {
            get => _sourceCache;
        }

        public string Name
        {
            get => _compileResult.Name;
            internal set => _compileResult.Name = value;
        }

        public ExpSchema Organize()
        {
            _compileResult.LoadFromSource(this);
            return _compileResult;
        }

        public void ReadSchema(ExpFileSource reader)
        {
            string line = reader.ReadLine();
            while (!_schemaBegin.IsMatch(line)) {
                line = reader.ReadLine();
            }
            name = _schemaBegin.Match(line).Groups["namespace"].Value;

            while (!_schemaEnd.IsMatch(line))
            {
                if (TryReadConst(line, reader, out IExpElementSource source))
                {
                    _sourceCache.Add(source);
                } else if (TryReadType(line, reader, out source))
                {
                    _sourceCache.Add(source);
                } else if (TryReadEntity(line, reader, out source))
                {
                    _sourceCache.Add(source);
                } else if (TryReadRule(line, reader, out source))
                {
                    _sourceCache.Add(source);
                } else if (TryReadFunction(line, reader, out source)) {
                    _sourceCache.Add(source);
                }
                line = reader.ReadLine();
            }
        }

        public static bool TryReadSchema(string firstLine, ExpFileSource reader, out ExpSchemaSource source)
        {
            if (!_schemaBegin.IsMatch(firstLine))
            {
                source = null!;
                return false;
            }
            ExpSchemaSource _source = new ExpSchemaSource();
            _source.name = _schemaBegin.Match(firstLine).Groups["namespace"].Value;

            while (!_schemaEnd.IsMatch(firstLine))
            {
                if (_source.TryReadConst(firstLine, reader,
                                          out IExpElementSource _elementSource))
                {
                    _source._sourceCache.Add(_elementSource);
                } else if (_source.TryReadType(firstLine, reader, out _elementSource))
                {
                    _source._sourceCache.Add(_elementSource);
                } else if (_source.TryReadEntity(firstLine, reader, out _elementSource))
                {
                    _source._sourceCache.Add(_elementSource);
                } else if (_source.TryReadRule(firstLine, reader, out _elementSource))
                {
                    _source._sourceCache.Add(_elementSource);
                } else if (_source.TryReadFunction(firstLine, reader, out _elementSource)) {
                    _source._sourceCache.Add(_elementSource);
                }
                firstLine = reader.ReadLine();
            }
            source = _source;
            return true;
        }

        [GeneratedRegex(@"\s*CONSTANT")]
        private static partial Regex GetConstDefineBegin();

        [GeneratedRegex(@"\s*END_CONSTANT;")]
        private static partial Regex GetConstDefineEnd();

        [GeneratedRegex(@"\s*ENTITY\s*(?<TypeName>[A-Za-z0-9_]+)\s*", RegexOptions.Compiled)]
        private static partial Regex GetEntityDefineBegin();

        [GeneratedRegex(@"\s*END_ENTITY;\s*--\s*(?<TypeName>[A-Za-z0-9_]+)\s*", RegexOptions.Compiled)]
        private static partial Regex GetEntityDefineEnd();

        [GeneratedRegex(@"\s*FUNCTION\s*\s*(?<FunctionName>[a-zA-Z0-9_]+)\s*(?<Remaining>.*)", RegexOptions.Compiled)]
        private static partial Regex GetFunctionDefineBegin();

        [GeneratedRegex(@"\s*END_FUNCTION\s*;\s*--\s*(?<FunctionName>[a-zA-Z0-9_]+)", RegexOptions.Compiled)]
        private static partial Regex GetFunctionDefineEnd();

        [GeneratedRegex(
                @"\s*RULE\s*(?<RuleName>[a-zA-Z0-9_]+)\s*FOR\s*\((?<Target>[a-zA-Z0-9_]*(?:\s*\)\s*;)?)",
                RegexOptions.Compiled)]
        private static partial Regex GetRuleDefineBegin();

        [GeneratedRegex(@"\s*END_RULE\s*;\s*--\s*(?<RuleName>[A-Za-z0-9_]+)", RegexOptions.Compiled)]
        private static partial Regex GetRuleDefineEnd();

        [GeneratedRegex(@"\s*SCHEMA\s*(?<namespace>[A-Za-z0-9_]+)\s?;")]
        private static partial Regex GetSchemaBegin();

        [GeneratedRegex(@"END_SCHEMA;\s*--\s*(?<namespace>[A-Za-z0-9_]+)", RegexOptions.Compiled)]
        private static partial Regex GetSchemaEnd();

        [GeneratedRegex(@"\s*TYPE\s+(?<TypeName>[A-Za-z0-9_]+)\s*=\s*(?<Remaining>[A-Z]+)", RegexOptions.Compiled)]
        private static partial Regex GetTypeDefineBegin();

        [GeneratedRegex(@"\s*END_TYPE\s*;\s*--\s*(?<TypeName>[a-zA-Z0-9_]+)", RegexOptions.Compiled)]
        private static partial Regex GetTypeDefineEnd();

        private bool TryReadConst(string firstLine, ExpFileSource reader, out IExpElementSource source)
        {
            Match match = _constDefineBegin.Match(firstLine);
            if (match.Success)
            {
                ScriptSourceTransmitter transmitter = new ScriptSourceTransmitter(
                    "END_CONSTANT", reader.Location);
                ExpConstantCollectionSource _source = new ExpConstantCollectionSource(transmitter);
                string line = reader.ReadLine();
                while (!_constDefineEnd.IsMatch(line))
                {
                    transmitter.WriteLine(line);
                    line = reader.ReadLine();
                }
                transmitter.WriteLine("END_CONSTANT");
                source = _source;
                return true;
            }
            source = null!;
            return false;
        }

        private bool TryReadEntity(string firstLine, ExpFileSource reader, out IExpElementSource source)
        {
            Match match = _entityDefineBegin.Match(firstLine);
            if (match.Success)
            {
                ScriptSourceTransmitter transmitter = new ScriptSourceTransmitter(
                    "END_ENTITY", reader.Location);
                ExpEntitySource _source = new ExpEntitySource(
                    match.Groups["TypeName"].ToString(), transmitter);
                string line = reader.ReadLine();
                match = _entityDefineEnd.Match(line);
                while (!match.Success)
                {
                    transmitter.WriteLine(line);
                    line = reader.ReadLine();
                    match = _entityDefineEnd.Match(line);
                }
                string endedName = match.Groups["TypeName"].ToString();
                if (!string.Equals(endedName, _source.Name)) {
                    throw new ExpInvalidElementDeclareEndingExceptions(_source.Name, endedName);
                }
                transmitter.WriteLine("END_ENTITY");
                source = _source;
                return true;
            }
            source = null!;
            return false;
        }

        private bool TryReadFunction(string firstLine, ExpFileSource reader, out IExpElementSource source)
        {
            Match match = _functionDefineBegin.Match(firstLine);
            if (match.Success)
            {
                ScriptSourceTransmitter transmitter = new ScriptSourceTransmitter(
                    "END_FUNCTION", reader.Location);
                ExpFunctionSource _source = new ExpFunctionSource(
                    match.Groups["FunctionName"].ToString(), transmitter);
                transmitter.WriteLine(match.Groups["Remaining"].ToString());
                string line = reader.ReadLine();
                match = _functionDefineEnd.Match(line);
                while (!match.Success)
                {
                    transmitter.WriteLine(line);
                    line = reader.ReadLine();
                    match = _functionDefineEnd.Match(line);
                }
                string endedName = match.Groups["FunctionName"].ToString();
                if (!string.Equals(endedName, _source.Name)) {
                    throw new ExpInvalidElementDeclareEndingExceptions(_source.Name, endedName);
                }
                transmitter.WriteLine("END_FUNCTION");
                source = _source;
                return true;
            }
            source = null!;
            return false;
        }

        private bool TryReadRule(string firstLine, ExpFileSource reader, out IExpElementSource source)
        {
            Match match = _ruleDefineBegin.Match(firstLine);
            if (match.Success)
            {
                ScriptSourceTransmitter transmitter = new ScriptSourceTransmitter(
                    "END_RULE", reader.Location);
                ExpRuleSource _source = new ExpRuleSource(
                    match.Groups["RuleName"].ToString(), transmitter);
                string target = match.Groups["Target"].ToString();
                if (!string.IsNullOrEmpty(target)) {
                    transmitter.WriteLine(target);
                }
                string line = reader.ReadLine();
                match = _ruleDefineEnd.Match(line);
                while (!match.Success)
                {
                    transmitter.WriteLine(line);
                    line = reader.ReadLine();
                    match = _ruleDefineEnd.Match(line);
                }
                string endedName = match.Groups["RuleName"].ToString();
                if (!string.Equals(endedName, _source.Name)) {
                    throw new ExpInvalidElementDeclareEndingExceptions(_source.Name, endedName);
                }
                transmitter.WriteLine("END_RULE");
                source = _source;
                return true;
            }
            source = null!;
            return false;
        }

        private bool TryReadType(string firstLine, ExpFileSource reader, out IExpElementSource source)
        {
            Match match = _typeDefineBegin.Match(firstLine);
            if (match.Success)
            {
                ScriptSourceTransmitter transmitter = new ScriptSourceTransmitter(
                    "END_ENTITY", reader.Location);
                ExpTypeSource _source = new ExpTypeSource(
                    match.Groups["TypeName"].ToString(), transmitter);
                transmitter.WriteLine(match.Groups["Remaining"].ToString());
                string line = reader.ReadLine();
                match = _typeDefineEnd.Match(line);
                while (!match.Success)
                {
                    transmitter.WriteLine(line);
                    line = reader.ReadLine();
                    match = _typeDefineEnd.Match(line);
                }
                string endedName = match.Groups["TypeName"].ToString();
                if (!string.Equals(endedName, _source.Name)) {
                    throw new ExpInvalidElementDeclareEndingExceptions(_source.Name, endedName);
                }
                transmitter.WriteLine("END_ENTITY");
                source = _source;
                return true;
            }
            source = null!;
            return false;
        }

    }
}