using NUnit.Framework;
using System.IO;
using System;
using System.Collections.Generic;

namespace NewLanguage
{
    [TestFixture]
    public class TestParser
    {
        [Test]
        public void Test1()
        {
            const string c_txt = @"typeref";

            List<NodeBase> toplevel = parse(c_txt);

            Assert.AreEqual(1, toplevel.Count);
            Assert.AreEqual("typeref", ((SymbolRefNode)toplevel[0]).Symbol.Name);
        }

        private List<NodeBase> parse(string input)
        {
            return parse(input, false);
        }

        private List<NodeBase> parse(string input, bool trace)
        {
            Parser parser = new Parser();
            Scanner scanner = new Scanner();
            scanner.SetSource(input, 0);
            parser.scanner = scanner;
            parser.Trace = trace;
            scanner.handler = parser.handler;
            Assert.IsTrue(parser.Parse(), "parse returned false");
            
            return new List<NodeBase>(parser.TopLevel);
        }

        [Test]
        public void TestSimpleSyntaxError()
        {
            bool caught = false;
            try
            {
                parse("num-nodes * * 2", false);
            }
            catch (ParseFailedException e)
            {
                StringAssert.Contains("unexpected '*'", e.Message);
                caught = true;
            }
            Assert.IsTrue(caught);
        }

        [Test]
        public void TestHyphenInIdent()
        {
            List<NodeBase> parsed = parse("num-nodes - 2", false);

            foreach (NodeBase node in parsed)
            {
                Console.WriteLine("  {0}", node);
            }
        
            Assert.AreEqual(1, parsed.Count);
            OperatorNode expr = (OperatorNode) parsed[0];
            Assert.AreEqual("-", expr.Op);
            Assert.AreEqual("num-nodes", ((SymbolRefNode)expr.Lhs).Symbol.Name);
            Assert.AreEqual("2", ((SymbolRefNode)expr.Rhs).Symbol.Name);
        }

        [Test]
        public void Test2()
        {
            List<NodeBase> parsed = parse("def var theStack as Stack[size > 0]", true);

            foreach (NodeBase node in parsed)
            {
                Console.WriteLine("  {0}", node);
            }
        
            Assert.AreEqual(1, parsed.Count);
            DeclarationNode decl = (DeclarationNode) parsed[0];
            Assert.AreEqual("theStack", decl.Symbol.Name);
            Assert.AreEqual("Stack", decl.TypeSpec.Type.Name);
            Assert.AreEqual(1, decl.TypeSpec.Constraint.Nodes.Count);
            Assert.AreEqual("size", ((SymbolRefNode)((OperatorNode)decl.TypeSpec.Constraint.Nodes[0]).Lhs).Symbol.Name);
            Assert.AreEqual("0", ((SymbolRefNode)((OperatorNode)decl.TypeSpec.Constraint.Nodes[0]).Rhs).Symbol.Name);
            Assert.AreEqual(">", ((OperatorNode)decl.TypeSpec.Constraint.Nodes[0]).Op);
        }

        [Test]
        [Ignore]
        public void Test3()
        {
            List<NodeBase> parsed = parse("def fun pop(Stack[size > 0] self) returning (Stack[size = size - 1],TItem)", true);

            foreach (NodeBase node in parsed)
            {
                Console.WriteLine("  {0}", node);
            }
        
        }
    }
}