"""
    Tests CQGI functionality

    Currently, this includes:
       Parsing a script, and detecting its available variables
       Altering the values at runtime
       defining a build_object function to return results
"""

from cadquery import cqgi
from tests import BaseTest
import textwrap

TESTSCRIPT = textwrap.dedent(
    """
        height=2.0
        width=3.0
        (a,b) = (1.0,1.0)
        foo="bar"

        result =  "%s|%s|%s|%s" % ( str(height) , str(width) , foo , str(a) )
        show_object(result)
    """
)

TEST_DEBUG_SCRIPT = textwrap.dedent(
    """
        height=2.0
        width=3.0
        (a,b) = (1.0,1.0)
        foo="bar"
        debug(foo, { "color": 'yellow' } )
        result =  "%s|%s|%s|%s" % ( str(height) , str(width) , foo , str(a) )
        show_object(result)
        debug(height )
    """
)


class TestCQGI(BaseTest):
    def test_parser(self):
        model = cqgi.CQModel(TESTSCRIPT)
        metadata = model.metadata

        self.assertEqual(set(metadata.parameters.keys()), {
                         'height', 'width', 'a', 'b', 'foo'})

    def test_build_with_debug(self):
        model = cqgi.CQModel(TEST_DEBUG_SCRIPT)
        result = model.build()
        debugItems = result.debugObjects
        self.assertTrue(len(debugItems) == 2)
        self.assertTrue(debugItems[0].shape == "bar")
        self.assertTrue(debugItems[0].options == {"color": 'yellow'})
        self.assertTrue(debugItems[1].shape == 2.0)
        self.assertTrue(debugItems[1].options == {})

    def test_build_with_empty_params(self):
        model = cqgi.CQModel(TESTSCRIPT)
        result = model.build()

        self.assertTrue(result.success)
        self.assertTrue(len(result.results) == 1)
        self.assertTrue(result.results[0].shape == "2.0|3.0|bar|1.0")

    def test_build_with_different_params(self):
        model = cqgi.CQModel(TESTSCRIPT)
        result = model.build({'height': 3.0})
        self.assertTrue(result.results[0].shape == "3.0|3.0|bar|1.0")

    def test_describe_parameters(self):
        script = textwrap.dedent(
            """
                a = 2.0
                describe_parameter(a,'FirstLetter')
            """
        )
        model = cqgi.CQModel(script)
        a_param = model.metadata.parameters['a']
        self.assertTrue(a_param.default_value == 2.0)
        self.assertTrue(a_param.desc == 'FirstLetter')
        self.assertTrue(a_param.varType == cqgi.NumberParameterType)

    def test_describe_parameter_invalid_doesnt_fail_script(self):
        script = textwrap.dedent(
            """
                a = 2.0
                describe_parameter(a, 2 - 1 )
            """
        )
        model = cqgi.CQModel(script)
        a_param = model.metadata.parameters['a']
        self.assertTrue(a_param.name == 'a')

    def test_build_with_exception(self):
        badscript = textwrap.dedent(
            """
                raise ValueError("ERROR")
            """
        )

        model = cqgi.CQModel(badscript)
        result = model.build({})
        self.assertFalse(result.success)
        self.assertIsNotNone(result.exception)
        self.assertTrue(result.exception.args[0] == "ERROR")

    def test_that_invalid_syntax_in_script_fails_immediately(self):
        badscript = textwrap.dedent(
            """
                this doesnt even compile
            """
        )

        with self.assertRaises(Exception) as context:
            model = cqgi.CQModel(badscript)

        self.assertTrue('invalid syntax' in context.exception.args)

    def test_that_two_results_are_returned(self):
        script = textwrap.dedent(
            """
                h = 1
                show_object(h)
                h = 2
                show_object(h)
            """
        )

        model = cqgi.CQModel(script)
        result = model.build({})
        self.assertEqual(2, len(result.results))
        self.assertEqual(1, result.results[0].shape)
        self.assertEqual(2, result.results[1].shape)

    def test_that_assinging_number_to_string_works(self):
        script = textwrap.dedent(
            """
                h = "this is a string"
                show_object(h)
            """
        )
        result = cqgi.parse(script).build({'h': 33.33})
        self.assertEqual(result.results[0].shape, "33.33")

    def test_that_assigning_string_to_number_fails(self):
        script = textwrap.dedent(
            """
                h = 20.0
                show_object(h)
            """
        )
        result = cqgi.parse(script).build({'h': "a string"})
        self.assertTrue(isinstance(result.exception,
                                   cqgi.InvalidParameterError))

    def test_that_assigning_unknown_var_fails(self):
        script = textwrap.dedent(
            """
                h = 20.0
                show_object(h)
            """
        )

        result = cqgi.parse(script).build({'w': "var is not there"})
        self.assertTrue(isinstance(result.exception,
                                   cqgi.InvalidParameterError))

    def test_that_cq_objects_are_visible(self):
        script = textwrap.dedent(
            """
                r = cadquery.Workplane('XY').box(1,2,3)
                show_object(r)
            """
        )

        result = cqgi.parse(script).build()
        self.assertTrue(result.success)
        self.assertIsNotNone(result.first_result)

    def test_that_options_can_be_passed(self):
        script = textwrap.dedent(
            """
                r = cadquery.Workplane('XY').box(1,2,3)
                show_object(r, options={"rgba":(128, 255, 128, 0.0)})
            """
        )

        result = cqgi.parse(script).build()
        self.assertTrue(result.success)
        self.assertIsNotNone(result.first_result.options)

    def test_setting_boolean_variable(self):
        script = textwrap.dedent(
            """
                h = True
                show_object( "*%s*" % str(h)  )
            """
        )

        result = cqgi.parse(script).build({'h': False})

        self.assertTrue(result.success)
        self.assertEqual(result.first_result.shape, '*False*')

    def test_that_only_top_level_vars_are_detected(self):
        script = textwrap.dedent(
            """
                h = 1.0
                w = 2.0

                def do_stuff():
                   x = 1
                   y = 2

                show_object( "result"  )
            """
        )

        model = cqgi.parse(script)

        self.assertEqual(2, len(model.metadata.parameters))
