# -*- encoding: utf-8 -*-
import os

from polls.models import Poll, Group, Field, Structure
from mock import Mock

from utils.test import (MongoTestCase, mock_in_memory_image,
                        remove_option_images_dir)
from polls.tests.poll_tests import MockImageFileInterface
from polls.exceptions import ReadOnly


class StructureTests(MongoTestCase):

    def setUp(self):
        poll = Poll(data={'name': 'name'})
        poll_id = poll.save()

        self.poll = Poll.get(id=poll_id)

        self.data = {
            'poll_id': 'POLL_ID',
            'groups': {
                '0': {
                    'name': 'group_0',
                    'fields': {
                        '0': {
                            'widget_type': Field.TextInput,
                            'name': 'field_0_0'
                        }
                    }
                }
            }
        }

    def test_structure(self):
        data = {
            'groups': {
                '0': {
                    'name': 'group_0',
                    'fields': {
                        '0': {
                            'widget_type': Field.TextInput,
                            'name': 'field_0_0'
                        },
                        '1': {
                            'widget_type': Field.RadioButton,
                            'name': 'field_0_1'
                        }
                    },
                },
                '1': {
                    'name': 'group_1',
                    'fields': {
                        '0': {
                            'widget_type': Field.MultipleCheckBox,
                            'name': 'field_1_0'
                        },
                        '1': {
                            'widget_type': Field.DropDownList,
                            'name': 'field_1_1'
                        }
                    },
                }
            }
        }

        structure = Structure(data=data, poll=self.poll)
        self.assertEqual(self.poll, structure.poll)

        group_0 = structure.groups[0]
        self.assertEqual(self.poll, group_0.poll)
        self.assertEqual(0, group_0.order)
        self.assertEqual('group_0', group_0.name)
        self.assertEqual(2, len(group_0.fields))

        group_1 = structure.groups[1]
        self.assertEqual(self.poll, group_1.poll)
        self.assertEqual(1, group_1.order)
        self.assertEqual('group_1', group_1.name)
        self.assertEqual(2, len(group_1.fields))

        field_0_0 = group_0.fields[0]
        self.assertEqual(self.poll, field_0_0.poll)
        self.assertEqual(0, field_0_0.order)
        self.assertEqual('field_0_0', field_0_0.name)
        self.assertEqual('TextInput', field_0_0.widget_type)

        field_0_1 = group_0.fields[1]
        self.assertEqual(self.poll, field_0_1.poll)
        self.assertEqual(1, field_0_1.order)
        self.assertEqual('field_0_1', field_0_1.name)
        self.assertEqual('RadioButton', field_0_1.widget_type)

        field_1_0 = group_1.fields[0]
        self.assertEqual(self.poll, field_1_0.poll)
        self.assertEqual(0, field_1_0.order)
        self.assertEqual('field_1_0', field_1_0.name)
        self.assertEqual('MultipleCheckBox', field_1_0.widget_type)

        field_1_1 = group_1.fields[1]
        self.assertEqual(self.poll, field_1_1.poll)
        self.assertEqual(1, field_1_1.order)
        self.assertEqual('field_1_1', field_1_1.name)
        self.assertEqual('DropDownList', field_1_1.widget_type)

    def test_is_valid(self):
        data = {
            'groups': {
                '0': {
                    'name': 'group_0',
                    'fields': {
                        '0': {  # has no options for a widget_type that needs
                            'widget_type': 'RadioButton',
                            'name': 'field_0_0'
                        },
                    }
                },
                '1': {
                    'name': '',  # has no name
                    'fields': {}  # has no fields
                }
            }
        }

        structure = Structure(data=data, poll=self.poll)

        self.assertFalse(structure.is_valid())

        field_0_0 = structure.groups[0].fields[0]

        self.assertEqual(1, len(field_0_0.errors))

        group_1 = structure.groups[1]

        self.assertEqual(2, len(group_1.errors))

    def test_not_valid_question_name(self):
        data = {
            'groups': {
                '0': {
                    'name': 'group_0',
                    'fields': {
                        '0': {
                            'widget_type': 'TextInput',
                            'name': ';'
                        },
                    }
                }
            }
        }

        structure = Structure(data=data, poll=self.poll)

        self.assertFalse(structure.is_valid())

    def test_invalid_structure(self):
        data = {}

        structure = Structure(data=data, poll=self.poll)

        self.assertFalse(structure.is_valid())

        self.assertEqual(1, len(structure.errors))

    def test_get(self):
        structure = Structure(data=self.data, poll=self.poll)
        structure_id = structure.save()

        structure = Structure.get(id=structure_id)

        self.assertEqual(self.poll.id, structure.poll.id)

    def test_to_python(self):

        expected = {
            'groups': {
                '0': {
                    'name': "group name",
                    'fields': {
                        '0': {
                            'name': "field_0_0",
                            'widget_type': Field.TextInput,
                            'options': {
                                '131212': {
                                    'text': "text",
                                    'order': 0
                                }
                            }
                        }
                    }
                },
                '1': {
                    'name': "group name",
                    'fields': {
                        '0': {
                            'name': "field_1_0",
                            'widget_type': Field.TextInput,
                            'options': {
                                '131212': {
                                    'text': "text",
                                    'order': 0
                                }
                            }
                        }
                    }
                }
            }
        }

        structure = Structure(poll=self.poll)

        field = Field({
            'name': "field_0_0",
            'widget_type': Field.TextInput,
            'order': 0
        })
        field.add_options({'131212': {'text': "text", 'order': 0}})

        group = Group({'name': "group name", 'order': 0})
        group.add_field(field, field.order)
        structure.add_group(group, group.order)

        field = Field({
            'name': "field_1_0",
            'widget_type': Field.TextInput,
            'order': 0
        })
        field.add_options({'131212': {'text': "text", 'order': 0}})

        group = Group({'name': "group name", 'order': 1})
        group.add_field(field, field.order)
        structure.add_group(group, group.order)

        self.assertEqual(expected, structure.to_python())

    def test_structure_with_a_question_with_img(self):

        poll = Poll({"name": "poll name"})
        poll_id = poll.save()
        poll = poll.get(poll_id)
        img = "img"
        data = {
            'groups': {
                '0': {
                    'name': "group name",
                    'fields': {
                        '0': {
                            'name': "field_0_0",
                            'widget_type': Field.TextInput,
                            'options': {
                                '131212': {
                                    'text': "text",
                                    'order': 0
                                }
                            },
                            'img': img
                        }
                    }
                }
            }
        }

        structure = Structure(data=data, poll=poll)

        self.assertEqual(img, structure.groups[0].fields[0].img)

    def test_save_field_image(self):
        img_name = "img_test.jpg"
        img = mock_in_memory_image(name=img_name)
        poll = self.poll
        data = self.data
        data['groups']['0']['fields']['0']['uploaded_file'] = img
        structure = Structure(data=data, poll=poll)

        s_id = structure.save()

        structure = Structure.get(id=s_id)

        self.assertEqual(
            img_name, structure.groups[0].fields[0].get_img_name())

    def test_get_img_options(self):
        poll = Poll({"name": "poll name"})
        poll_id = poll.save()
        poll = poll.get(poll_id)
        img = "img"
        data = {
            'groups': {
                '0': {
                    'name': "group name",
                    'fields': {
                        '0': {
                            'name': "field_0_0",
                            'widget_type': Field.ImageCheckBox,
                            'options': {
                                '131212': {
                                    'img': MockImageFileInterface(),
                                    'text': "text",
                                    'order': 0
                                }
                            },
                            'img': img
                        }
                    }
                }
            }
        }

        structure = Structure(data=data, poll=poll)

        self.assertEqual(1, len(structure.get_image_options()))

    def test_it_should_respond_to_ready_only_msg(self):
        self.assertTrue(hasattr(Structure, 'READ_ONLY_MSG'))


class ReadOnlyTest(MongoTestCase):

    def setUp(self):
        poll = Poll({"name": "poll name"})
        poll_id = poll.save()
        self.poll = poll.get(poll_id)

    def test_it_should_be_read_only_when_poll_has_results(self):
        poll = self.poll
        structure = Structure(data={}, poll=poll)
        self.assertFalse(poll.has_result())
        self.assertFalse(structure.is_read_only())

        poll.has_result = Mock(return_value=True)
        self.assertTrue(poll.has_result())
        self.assertTrue(structure.is_read_only())

    def test_read_only_when_poll_is_closed_and_has_not_results(self):
        poll = self.poll
        poll.status = Poll.CLOSED
        poll_id = poll.save()
        poll = poll.get(poll_id)

        structure = Structure(data={}, poll=poll)
        self.assertFalse(poll.has_result())
        self.assertFalse(poll.is_open())

        self.assertTrue(structure.is_read_only())


class UploadOptionImagesTest(MongoTestCase):

    def setUp(self):
        self.option_id = '131212'
        self.data = {
            'groups': {
                '0': {
                    'name': "group name",
                    'fields': {
                        '0': {
                            'name': "field_0_0",
                            'widget_type': Field.ImageCheckBox,
                            'options': {
                                self.option_id: {
                                    'img': None,
                                    'text': "text",
                                    'order': 0
                                }
                            }
                        }
                    }
                }
            }
        }
        poll = Poll({"name": "poll name"})
        poll_id = poll.save()
        self.poll = poll.get(poll_id)

        img_ext = "jpg"
        self.img_filename = '.'.join([self.option_id, img_ext])
        self.img = Mock()
        self.img.chunks = Mock(return_value=['chunk', 'chunk'])
        self.img.name = self.img_filename

    def test_it_should_save_option_images_with_many_chunks(self):
        option_id = self.option_id
        img = self.img
        img_filename = self.img_filename

        data = self.data
        data['groups']['0']['fields']['0']['options'][option_id]['img'] = img
        poll = self.poll
        structure = Structure(data=data, poll=poll)

        structure.save_image_options()

        images_dir = structure.get_image_options_path()
        saved_on_disk = os.path.exists(os.path.join(images_dir, img_filename))
        self.assertTrue(saved_on_disk)

    def test_save_imgs_when_exists_a_valid_structure_with_temp_imgs(self):
        option_id = self.option_id
        poll = self.poll
        data = self.data
        data_option = data['groups']['0']['fields']['0']['options'][option_id]
        img_filename = self.img_filename
        img = self.img

        data_option['img'] = img
        structure = Structure(data=data, poll=poll)
        structure.save_image_options(tmp=True)
        images_tmp_dir = structure.get_image_options_tmp_path()
        saved_on_tmp_dir = os.path.exists(
            os.path.join(images_tmp_dir, img_filename))
        self.assertTrue(saved_on_tmp_dir)

        data = structure.to_python()
        structure = Structure(data=data, poll=poll)
        structure.save_image_options(tmp=False)

        images_dir = structure.get_image_options_path()
        saved_on_right_place = os.path.exists(
            os.path.join(images_dir, img_filename))
        self.assertTrue(saved_on_right_place)
        self.assertFalse(os.path.exists(images_tmp_dir))

    def tearDown(self):
        remove_option_images_dir()


class SaveStructureTest(MongoTestCase):

    def setUp(self):
        poll = Poll(data={'name': 'name'})
        poll_id = poll.save()

        self.poll = Poll.get(id=poll_id)

        self.data = {
            'poll_id': 'POLL_ID',
            'groups': {
                '0': {
                    'name': 'group_0',
                    'fields': {
                        '0': {
                            'widget_type': Field.TextInput,
                            'name': 'field_0_0'
                        }
                    }
                }
            }
        }

    def test_save(self):
        structure = Structure(data=self.data)
        self.assertRaises(structure.ValidationError, structure.save)

        structure = Structure(data=self.data, poll=self.poll)
        structure.save()
        self.assertEqual(1, self.db.structures.count())

    def test_it_should_not_save_if_is_read_only(self):
        poll = self.poll
        structure = Structure(data=self.data, poll=poll)
        structure.is_read_only = Mock(return_value=True)
        self.assertRaises(ReadOnly, structure.save)