import unittest
import decimal
import pyaccuwage
from pyaccuwage.fields import BlankField
from pyaccuwage.fields import IntegerField
from pyaccuwage.fields import MoneyField
from pyaccuwage.fields import StateField
from pyaccuwage.fields import TextField
from pyaccuwage.fields import ZeroField
from pyaccuwage.model import Model

class TestModelOutput(unittest.TestCase):
    class TestModel(Model):
        record_length = 128
        record_identifier = 'TEST'  # 4 bytes
        field1 = TextField(max_length=16)
        field2 = IntegerField(max_length=16)
        blank1 = BlankField(max_length=16)
        zero1 = ZeroField(max_length=16)
        money = MoneyField(max_length=32)
        state_txt = StateField()
        state_num = StateField(use_numeric=True)
        blank2 = BlankField(max_length=24)

    def setUp(self):
        self.model = TestModelOutput.TestModel()

    def testModelBinaryOutput(self):
        model = self.model
        model.field1.value = 'Hello, sir!'
        model.field2.value = 12345
        model.money.value = decimal.Decimal('3133.77')
        model.state_txt.value = 'IA'
        model.state_num.value = 'IA'

        expected = b''.join([
            b'TEST',
            b'HELLO, SIR!'.ljust(16),
            b'12345'.zfill(16),
            b' ' * 16,
            b'0' * 16,
            b'313377'.zfill(32),
            b'IA',
            b'19',
            b' ' * 24,
            ])

        output = model.output()
        self.assertEqual(len(output), TestModelOutput.TestModel.record_length)
        self.assertEqual(output, expected)

    def testModelTextOutput(self):
        model = self.model
        model.field1.value = 'Hello, sir!'
        model.field2.value = 12345
        model.money.value = decimal.Decimal('3133.77')
        model.state_txt.value = 'IA'
        model.state_num.value = 'IA'
        output = model.output(format='text')

        self.assertEqual(output, '''---TestModel
field1: Hello, sir!
field2: 12345
money: 3133.77
state_txt: IA
state_num: IA

''')


class TestFileFormats(unittest.TestCase):
    class TestModelA(pyaccuwage.model.Model):
        record_length = 128
        record_identifier = 'A'  # 1 byte
        field1 = TextField(max_length=16)
        field2 = IntegerField(max_length=16)
        blank1 = BlankField(max_length=16)
        zero1 = ZeroField(max_length=16)
        money = MoneyField(max_length=32)
        state_txt = StateField()
        state_num = StateField(use_numeric=True)
        blank2 = BlankField(max_length=27)

    class TestModelB(pyaccuwage.model.Model):
        record_length = 128
        record_identifier = 'B'  # 1 byte
        zero1 = ZeroField(max_length=32)
        text1 = TextField(max_length=71)
        blank2 = BlankField(max_length=24)

    record_types = [TestModelA, TestModelB]

    def createExampleRecords(self):
        model_a = TestFileFormats.TestModelA()
        model_a.field1.value = 'I am model a'
        model_a.field2.value = 5522
        model_a.money.value = decimal.Decimal('23.00')
        model_a.state_txt.value = 'IA'
        model_a.state_num.value = 'IA'

        model_b = TestFileFormats.TestModelB()
        model_b.text1.value = 'hey I am model b and I have a big text field'

        return [
            model_a,
            model_b,
        ]

    def testJSONSerialization(self):
        records = self.createExampleRecords()
        record_types = self.record_types
        json_data = pyaccuwage.json_dumps(records)
        records_loaded = pyaccuwage.json_loads(json_data, record_types)

        original_bytes = pyaccuwage.dumps(records)
        reloaded_bytes = pyaccuwage.dumps(records_loaded)
        self.assertEqual(original_bytes, reloaded_bytes)

    def testTxtSerialization(self):
        records = self.createExampleRecords()
        record_types = self.record_types
        text_data = pyaccuwage.text_dumps(records)
        records_loaded = pyaccuwage.text_loads(text_data, record_types)

        original_bytes = pyaccuwage.dumps(records)
        reloaded_bytes = pyaccuwage.dumps(records_loaded)
        self.assertEqual(original_bytes, reloaded_bytes)