import c3
import time, ppci, x86, ir
import unittest
import glob

testsrc = """module test;

/*
 demo of the source that is correct :)
*/ 
var int c, d;
var double e;
var int f;

const int A = 1337;

function void test1()
{
    var int bdd;
    var int a = 10;
    bdd = 20;
    var int buf;
    var int i;
    i = 2;
    var int zero = i - 2;
    if (i > 1)
    {
       buf = b + 22 * i - 13 + (55 * 2 *9-2) / 44 - 1;
    }
    else
    {
      ;;;
    }

    t2(2, 3);
}

function int t2(int a, int b)
{
   if (a > 0)
   {
      a = 2 + t2(a - 1, 10);
   }

   return a + b;
}

var int a, b;

function int t3(int aap, int blah)
{
   if (a > blah and blah < 45 + 33 or 33 > aap or 6 > 2 and true)
   {
      a = 2 + t2(a - 1, 0);
   }

   return a + b;
}

var int hahaa = 23 * 2;


"""

class testLexer(unittest.TestCase):
    def testUnexpectedCharacter(self):
        snippet = """ var s \u6c34 """
        with self.assertRaises(ppci.CompilerError):
            list(c3.lexer.tokenize(snippet))

    def testBlockComment(self):
        snippet = """
          /* Demo */
          var int x = 0;
        """
        toks = ['var', 'ID', 'ID', '=', 'NUMBER', ';', 'END']
        self.assertSequenceEqual([tok.typ for tok in c3.lexer.tokenize(snippet)], toks)

    def testBlockCommentMultiLine(self):
        snippet = """
          /* Demo
          bla1
          bla2
          */
          var int x = 0;
        """
        toks = ['var', 'ID', 'ID', '=', 'NUMBER', ';', 'END']
        self.assertSequenceEqual([tok.typ for tok in c3.lexer.tokenize(snippet)], toks)

class testBuilder(unittest.TestCase):
    def setUp(self):
        self.diag = ppci.DiagnosticsManager()
        self.builder = c3.Builder(self.diag)
        self.diag.clear()

    def testSrc(self):
        self.expectOK(testsrc)

    def expectErrors(self, snippet, rows):
        """ Helper to test for expected errors on rows """
        ircode = self.builder.build(snippet)
        actualErrors = [err.row for err in self.diag.diags]
        if rows != actualErrors:
            self.diag.printErrors(snippet)
        self.assertSequenceEqual(rows, actualErrors)
        self.assertFalse(ircode)

    def expectOK(self, snippet, pack_dir=None):
        ircode = self.builder.build(snippet, pack_dir=pack_dir)
        if not ircode:
            self.diag.printErrors(snippet)
        self.assertTrue(ircode)
        return ircode

    def testPackage(self):
        p1 = """module p1;
        type int A;
        """
        self.assertTrue(self.builder.build(p1))
        p2 = """module p2;
        import p1;
        var A b;
        """
        self.expectOK(p2)

    def testFunctArgs(self):
      snippet = """
         module testargs;
         function void t2(int a, double b)
         {
            t2(2, 2);
            t2(2);
            t2(1, 1.2);
         }
      """
      self.expectErrors(snippet, [5, 6])

    def testExpressions(self):
      snippet = """
         module test;
         function void t(int a, double b)
         {
            var int a2;
            var bool c;

            a2 = b * a;
            c = a;
            c = b > 1;
         }
      """
      self.expectErrors(snippet, [8, 9, 10])

    def testExpression1(self):
      snippet = """
         module testexpr1;
         function void t()
         {
            var int a, b, c;
            a = 1;
            b = a * 2 + a * a;
            c = b * a - 3;
         }
      """
      self.expectOK(snippet)

    def testEmpty(self):
      snippet = """
      module A
      """
      self.expectErrors(snippet, [3])

    def testEmpty2(self):
      snippet = ""
      self.expectErrors(snippet, [1])

    def testRedefine(self):
      snippet = """
      module test;
      var int a;
      var int b;
      var int a;
      """
      self.expectErrors(snippet, [5])

    def testWhile(self):
      snippet = """
      module tstwhile;
      var int a;
      function void t()
      {
         var int i = 0;
         while (i < 1054)
         {
            i = i + 3;
            a = a + i;
         }

         while(true)
         {
         }

         while(false)
         {
         }
      }
      """
      self.expectOK(snippet)

    def testIf(self):
        snippet = """
      module tstIFF;
      function void t(int b)
      {
         var int a;
         a = 2;
         if (a > b)
         {
            if (a > 1337)
            {
               b = 2;
            }
         }
         else
         {
            b = 1;
         }

         return b;
      }
        """
        self.expectOK(snippet)

    def testTypeDef(self):
        snippet = """
         module testtypedef;
         type int my_int;
         function void t()
         {
            var my_int a;
            var int b;
            a = 2;
            b = a + 2;
         }
        """
        self.expectOK(snippet)

    def testLocalVariable(self):
        snippet = """
         module testlocalvar;
         function void t()
         {
            var int a, b;
            a = 2;
            b = a + 2;
         }
        """
        self.expectOK(snippet)

    def testUnknownType(self):
        snippet = """module testlocalvar;
         function void t()
         {
            var int2 a;
         }
        """
        self.expectErrors(snippet, [4])

    def testStruct1(self):
        snippet = """
         module teststruct1;
         function void t()
         {
            var struct {int x, y;} a;
            a.x = 2;
            a.y = a.x + 2;
         }
        """
        self.expectOK(snippet)

    def testPointerType1(self):
        snippet = """
         module testpointer1;
         var int* pa;
         function void t()
         {
            var int a;
            pa = &a;
            *pa = 22;
         }
        """
        self.expectOK(snippet)

    def testPointerType(self):
        snippet = """
         module testpointer;
         var int* pa, pb;
         function void t(int a, double b)
         {
            var int a2;
            a2 = a; // parameters cannot be escaped for now..
            pa = &a2;
            pb = pa;
            *pa = 22;
         }
        """
        self.expectOK(snippet)

    def testPointerTypeInCorrect(self):
        snippet = """
         module testpointerincorrect;
         var int* pa;
         function void t(int a, double b)
         {
            pa = 2; // type conflict
            pa = &a;
            pa = &2;
            &a = pa; // No valid lvalue
            **pa = 22; // Cannot deref int
         }
        """
        self.expectErrors(snippet, [6, 9, 10])

    def testPointerTypeIr(self):
        snippet = """
         module testptr_ir;
         function void t()
         {
            var int* a;
            a = cast<int*>(40);
            *a = 2;
         }
        """
        self.expectOK(snippet)

    def testPointerTypeIr2(self):
        snippet = """
         module testptr_ir;
         type struct {int x,y;}* gpio;
         function void t()
         {
            var gpio a;
            a = cast<gpio>(40);
            a->x = 2;
            a->y = a->x - 14;
         }
        """
        self.expectOK(snippet)

    def testWrongCast(self):
        snippet = """
         module testptr_ir;
         type struct {int x,y;}* gpio;
         function void t()
         {
            var gpio a;
            *cast<gpio>(*a);
         }
        """
        # TODO: remove the duplicate error:
        self.expectErrors(snippet, [7, 7])

    def testComplexType(self):
        snippet = """
         module testpointer;
         type int my_int;

         type struct {
          int x, y;
         } point;

         type struct {
           int mem1;
           int memb2;
           point P1;
         } my_struct;

         type my_struct* my_sptr;
         var int* pa;

         function void t(int a, int b, my_sptr x)
         {
            var my_struct *msp;

            var my_struct u, v;
            var point *pt;

            pt = &msp->P1;
            msp = x;
            *pa = 22 + u.mem1 * v.memb2 - u.P1.x;
            x->memb2 = *pa + a * b;

            msp->P1.x = a * x->P1.y;
         }
        """
        self.expectOK(snippet)

    def testExamples(self):
        """ Test all examples in the c3/examples directory """
        example_filenames = glob.glob('./c3/examples/*.c3')
        for filename in example_filenames:
            with open(filename, 'r') as f:
                src = f.read()
            self.expectOK(src, pack_dir='./c3/examples')

    def test2(self):
        # testsrc2 is valid code:
        snippet = """
        module test2;

        function void tst()
        {
           var int a, b;
           a = 2 * 33 - 12;
           b = a * 2 + 13;
           a = b + a;
           if (a > b and b == 3)
           {
              var int x = a;
              x = b * 2 - a;
              a = x*x;
           }
           else
           {
              a = b + a;
           }
        }

        """
        ircode = self.expectOK(snippet)
        self.assertEqual(1, len(ircode.Functions))

if __name__ == '__main__':
    unittest.main()