from ppci.c3 import Builder, Lexer
from target import SimpleTarget
import ppci
import unittest
import io


class testLexer(unittest.TestCase):
    def setUp(self):
        diag = ppci.DiagnosticsManager()
        self.l = Lexer(diag)

    def testUnexpectedCharacter(self):
        snippet = io.StringIO(""" var s \u6c34 """)
        with self.assertRaises(ppci.CompilerError):
            list(self.l.tokenize(snippet))

    def check(self, snippet, toks):
        toks2 = list(tok.typ for tok in self.l.tokenize(io.StringIO(snippet)))
        self.assertSequenceEqual(toks, toks2)

    def testBlockComment(self):
        snippet = """
          /* Demo */
          var int x = 0;
        """
        toks = ['var', 'ID', 'ID', '=', 'NUMBER', ';', 'END']
        self.check(snippet, toks)

    def testBlockCommentMultiLine(self):
        snippet = """
          /* Demo
          bla1
          bla2
          */
          var int x = 0;
        """
        toks = ['var', 'ID', 'ID', '=', 'NUMBER', ';', 'END']
        self.check(snippet, toks)


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

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

    def expectOK(self, snippet):
        if type(snippet) is list:
            ircode = self.builder.build(snippet)
        else:
            ircode = self.builder.build([io.StringIO(snippet)])
        if not ircode:
            self.diag.printErrors(snippet)
        self.assertTrue(all(ircode))
        return ircode

    def testPackage(self):
        p1 = """module p1;
        type int A;
        """
        p2 = """module p2;
        import p1;
        var A b;
        """
        self.expectOK([io.StringIO(s) for s in (p1, p2)])

    def testPackageMutual(self):
        p1 = """module p1;
        import p2;
        type int A;
        var p2.B b;
        """
        p2 = """module p2;
        import p1;
        var p1.A a;
        """
        self.expectOK([io.StringIO(s) for s in (p1, p2)])

    def testPackageNotExists(self):
        p1 = """module p1;
        import p23;
        """
        self.expectOK([io.StringIO(p1)])

    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 testReturn(self):
        snippet = """
         module testreturn;
         function void t()
         {
            return;
         }
        """
        self.expectOK(snippet)

    def testReturn2(self):
        snippet = """
         module testreturn;
         function int t()
         {
            return 2;
         }
        """
        self.expectOK(snippet)

    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 testStructCall(self):
        snippet = """
         module teststruct1;
         function void t()
         {
            var struct {int x, y;} a;
            a.b.c(9);
         }
        """
        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);
         }
        """
        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)


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