//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//     file="ExpLinearExpressionTest.cs"
//     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.Script;
using StgSharp.Script.Express;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Schema;

namespace StgSharp
{
    internal class ExpTestFuncSource : ExpFunctionSource
    {

        public ExpTestFuncSource( string name, ScriptSourceTransmitter source )
            : base( name, source )
        {
            LocalVariables.Add(
                "a", new ExpIntNode( new Token( "a", 0, 0, TokenFlag.Number ), 1, false ) );
            LocalVariables.Add(
                "b", new ExpIntNode( new Token( "b", 0, 0, TokenFlag.Number ), 1, false ) );
            LocalVariables.Add(
                "c", new ExpIntNode( new Token( "c", 0, 0, TokenFlag.Number ), 1, false ) );
            LocalVariables.Add(
                "d", new ExpIntNode( new Token( "d", 0, 0, TokenFlag.Number ), 1, false ) );
            LocalVariables.Add(
                "e", new ExpIntNode( new Token( "e", 0, 0, TokenFlag.Number ), 1, false ) );
        }

    }

    internal class TestSchema : ExpSchema
    {

        internal ExpTestFuncSource source;

        public TestSchema( ExpTestFuncSource testType )
        {
            source = testType;
        }

        public override void LoadFromSource( ExpSchemaSource source )
        {
            return;
        }

        public override bool TryGetConst( string name, out ExpElementInstance c )
        {
            c = null;
            return false;
        }

        public override bool TryGetEntity( string name, out ExpEntitySource e )
        {
            e = null;
            return false;
        }

        public override bool TryGetFunction( string name, out ExpFunctionSource f )
        {
            if( name == "TestFunc" )
            {
                f = source;
                return true;
            }
            f = null;
            return false;
        }

        public override bool TryGetProcedure( string name, out ExpProcedureSource p )
        {
            p = null;
            return false;
        }

        public override bool TryGetRule( string name, out ExpRuleSource r )
        {
            r = null;
            return false;
        }

        public override bool TryGetSchemaInclude( string name, out ExpSchema include )
        {
            include = null;
            return false;
        }

        public override bool TryGetType( string name, out ExpTypeSource t )
        {
            t = null;
            return false;
        }

    }

    internal static partial class Program
    {

        private const string code = """
            a := ( b * E + d * 2 ) * d;
            (**)
            a := b + (c + d) - a;      
            IF a = b THEN
                a := a * a;
            ELSE
                a := c * a;
            END_IF
            (**)
            CASE a OF
                1 : a := 1 + e ;
                OTHERWISE : a:=a;
            END_CASE
            REPEAT a := 1 TO 10;
                b := 10;
            END_REPEAT
            """;

        public static void ExpLinearExpressionTest()
        {
            ExpressCompile.InitCompile();
            ScriptSourceTransmitter transmitter = new ScriptSourceTransmitter( "END", 0 );

            foreach( string line in code.Split(
                Environment.NewLine, StringSplitOptions.RemoveEmptyEntries ) ) {
                transmitter.WriteLine( line );
            }
            transmitter.EndWriting();
            ExpTokenReader reader = new ExpTokenReader( transmitter );
            /**/
            ExpTestFuncSource func = new ExpTestFuncSource( "test", transmitter );
            TestSchema testSchema = new TestSchema( func );
            ExpSyntaxAnalyzer generator = new ExpSyntaxAnalyzer( testSchema, func );
            /**/

            while( reader.TryReadToken( out Token t ) )
            {
                Console.WriteLine( t.Value );
                generator.AppendToken( t );
            }
            Console.WriteLine( "OK" );
        }

    }
}