# coding=utf-8 #
from openerp import models, exceptions, fields, api
import datetime
import math


class Lesson(models.Model):
    _name = 'kspu.table.lesson'
    _rec_name = 'subject'

    subject = fields.Many2one(string=u'Название предмета', comodel_name='kspu.table.subject', required=True)
    type = fields.Selection(selection=[
        ('lecture', u'Лекция'),
        ('seminar', u'Семинар'),
        ('lab', u'Лабораторное занятие'),
        ('individual', u'Индивидуальная работа'),
    ], string=u'Тип', required=True, default='lecture')
    validity_from = fields.Datetime(
        string=u'Дата и время начала', default=lambda *a: datetime.datetime.now().strftime('%Y-%m-%d'),
        required=True)
    validity_to = fields.Datetime(
        string=u'Дата и время окончания',
        default=lambda *a: (datetime.datetime.now() + datetime.timedelta(hours=1.5)).strftime('%Y-%m-%d'),
        required=True)
    # lesson_number_show = fields.Selection(selection=[
    #     ('one', u'1 лента (8.40 - 10.10)'),
    #     ('two', u'2 лента (10.20 - 11.50)'),
    #     ('three', u'3 лента (12.20 - 13.50)'),
    #     ('four', u'4 лента (14.00 - 15.30)'),
    #     ('five', u'5 лента (15.40- 17.10)'),
    #     ('six', u'6 лента (17.20- 18.50)'),
    #     ('seven', u'7 лента (19.00- 20.30)'),
    #     ('eight', u'8 лента (20.40- 22.10)'),
    # ], string=u'Лента', required=True)
    lesson_number_show = fields.Many2one(string=u'Лента', comodel_name='kspu.table.slots', required=True)
    lesson_date_show = fields.Date(string=u'Дата занятия', required=True)
    lesson_validity = fields.Char(string=u'Время по номеру ленты', compute='datetime_on_number', store=True)
    lesson_number = fields.Char(string=u'Номер ленты по времени ленты', compute='number_on_datetime', store=True)
    lesson_date = fields.Char(string=u'Дата по времени ленты', compute='date_on_datetime', store=True)
    level = fields.Selection(string=u'Курс', related='group.level', required=True)
    group = fields.Many2one(string=u'Группа', comodel_name='kspu.table.group', required=True)
    subgroup = fields.Selection(selection=[
        ('full', u'Полная'),
        ('A', u'подгруппа A'),
        ('B', u'подгруппа B'),
    ], string=u'Подгруппа', default='full', required=True)
    department = fields.Many2one(string=u'Факультет', related='group.department')
    amount = fields.Integer(string=u'Численность группы', related='group.amount')
    teacher = fields.Many2one(string=u'Преподаватель', comodel_name='kspu.table.teacher', required=True)
    cabinet = fields.Many2one(string=u'Аудитория', comodel_name='kspu.table.cabinet', required=True)
    roominess = fields.Char(string=u'Вместительность', related='cabinet.roominess')
    week_number = fields.Char(string=u'Номер недели', compute='compute_week', store=True)
    week_show = fields.Char(string=u'Неделя', compute='compute_week')

    # Недели
    @api.one
    @api.depends('validity_from')
    def compute_week(self):
        self.week_number = fields.Date.from_string(self.validity_from).isocalendar()[1]
        validity_from_dt = fields.Datetime.from_string(self.validity_from)

        week_from = datetime.datetime.strptime(
            (str(validity_from_dt.year) + "." + str(self.week_number) + "." + str(1)), "%Y.%W.%w")
        week_to = datetime.datetime.strptime(
            (str(validity_from_dt.year) + "." + str(self.week_number) + "." + str(0)), "%Y.%W.%w")
        self.week_show = u'{0} неделя (с {1} по {2})'.format(
            self.week_number, week_from.strftime('%d.%m.%Y'), week_to.strftime('%d.%m.%Y'))

    # Логика лент
    @api.one
    @api.constrains('lesson_number_show')
    def datetime_on_number(self):
        current_lesson_number = self.lesson_number_show
        current_time_start = self.check_time_start
        current_time_end = self.check_time_end
        lesson_date_d = fields.Date.from_string(self.lesson_date_show)


        # for current_lesson_number:
        #     if self.validity_from != fields.Datetime.to_string(datetime.datetime(
        #             lesson_date_d.year, lesson_date_d.month, lesson_date_d.day, 1, 40, 0)):
        #         self.validity_from = fields.Datetime.to_string(datetime.datetime(
        #             lesson_date_d.year, lesson_date_d.month, lesson_date_d.day, 1, 40, 0))
        #     if self.validity_to != fields.Datetime.to_string(datetime.datetime(
        #             lesson_date_d.year, lesson_date_d.month, lesson_date_d.day, 3, 10, 0)):
        #         self.validity_to = fields.Datetime.to_string(datetime.datetime(
        #             lesson_date_d.year, lesson_date_d.month, lesson_date_d.day, 3, 10, 0))

    @api.one
    @api.constrains('validity_from')
    def number_on_datetime(self):
        validity_from_dt = fields.Datetime.from_string(self.validity_from)

        if (validity_from_dt.hour < 3) or (validity_from_dt.hour == 3 and validity_from_dt.minute <= 10):
            self.lesson_number_show = 'one'
        if (validity_from_dt.hour == 3 and validity_from_dt.minute > 10) or (
                        validity_from_dt.hour == 4 and validity_from_dt.minute <= 50):
            self.lesson_number_show = 'two'
        if (validity_from_dt.hour == 4 and validity_from_dt.minute > 50) or (validity_from_dt.hour == 5) or (
                        validity_from_dt.hour == 6 and validity_from_dt.minute <= 50):
            self.lesson_number_show = 'three'
        if (validity_from_dt.hour == 6 and validity_from_dt.minute > 50) or (validity_from_dt.hour == 7) or (
                        validity_from_dt.hour == 8 and validity_from_dt.minute <= 30):
            self.lesson_number_show = 'four'
        if (validity_from_dt.hour == 8 and validity_from_dt.minute > 30) or (validity_from_dt.hour == 9) or (
                        validity_from_dt.hour == 10 and validity_from_dt.minute <= 10):
            self.lesson_number_show = 'five'
        if (validity_from_dt.hour == 10 and validity_from_dt.minute > 10) or (
                        validity_from_dt.hour == 11 and validity_from_dt.minute <= 50):
            self.lesson_number_show = 'six'
        if (validity_from_dt.hour == 11 and validity_from_dt.minute > 50) or (validity_from_dt.hour == 12) or (
                        validity_from_dt.hour == 13 and validity_from_dt.minute <= 30):
            self.lesson_number_show = 'seven'
        if (validity_from_dt.hour == 13 and validity_from_dt.minute > 30) or (validity_from_dt.hour == 14) or (
                        validity_from_dt.hour == 15) or (validity_from_dt.hour == 16):
            self.lesson_number_show = 'eight'

    @api.one
    @api.constrains('validity_from')
    def date_on_datetime(self):
        validity_from_dt = fields.Datetime.from_string(self.validity_from)

        self.lesson_date_show = datetime.date(validity_from_dt.year, validity_from_dt.month, validity_from_dt.day)

    @api.one
    @api.constrains('lesson_date_show')
    def datetime_on_date(self):
        validity_from_dt = fields.Datetime.from_string(self.validity_from)
        lesson_date_show = fields.Date.from_string(self.lesson_date_show)
        new_validity_from = datetime.datetime(lesson_date_show.year, lesson_date_show.month, lesson_date_show.day,
                                              validity_from_dt.hour, validity_from_dt.minute)

        if validity_from_dt != new_validity_from:
            self.validity_from = new_validity_from

    # Проверка коллизий
    @api.one
    @api.constrains('teacher', 'cabinet', 'validity_from')
    def check_teacher_bifurcation(self):
        lesson_ids = self.env['kspu.table.lesson'].search(
            [('teacher', '=', self.teacher.id), ('validity_from', '=', self.validity_from),
             ('cabinet', '!=', self.cabinet.id), ('id', '!=', self.id)])
        if len(lesson_ids):
            raise exceptions.ValidationError(
                u"Ошибка: у данного преподавателя уже есть лента в другом кабинете в это время")

    @api.one
    @api.constrains('teacher', 'cabinet', 'validity_from')
    def check_teacher_intersection(self):
        lesson_ids = self.env['kspu.table.lesson'].search(
            [('teacher', '!=', self.teacher.id), ('validity_from', '=', self.validity_from),
             ('cabinet', '=', self.cabinet.id), ('id', '!=', self.id)])
        if len(lesson_ids):
            raise exceptions.ValidationError(
                u"Ошибка: разные преподаватели не могут быть в одном кабинете в одно время")

    @api.one
    @api.constrains('subject', 'group', 'teacher', 'cabinet', 'validity_from')
    def check_complete_coincidence(self):
        lesson_ids = self.env['kspu.table.lesson'].search(
            [('teacher', '=', self.teacher.id), ('validity_from', '=', self.validity_from),
             ('cabinet', '=', self.cabinet.id), ('id', '!=', self.id), ('subject', '=', self.subject.id),
             ('group', '=', self.group.id), ('subgroup', '=', self.subgroup)])
        if len(lesson_ids):
            raise exceptions.ValidationError(
                u"Ошибка: полное совпадение лент")

    @api.one
    @api.constrains('subject', 'cabinet', 'validity_from')
    def check_lesson_intersection(self):
        lesson_ids = self.env['kspu.table.lesson'].search(
            [('subject', '!=', self.subject.id), ('validity_from', '=', self.validity_from),
             ('cabinet', '=', self.cabinet.id), ('id', '!=', self.id)])
        if len(lesson_ids):
            raise exceptions.ValidationError(
                u"Ошибка: разные предметы не могут проходить в одном кабинете в одно время")


class Subject(models.Model):
    _name = 'kspu.table.subject'
    _rec_name = 'name'

    name = fields.Char(string=u'Название предмета')
    lesson_id = fields.One2many(comodel_name='kspu.table.lesson', inverse_name='subject')


class Teacher(models.Model):
    _name = 'kspu.table.teacher'
    _rec_name = 'full_name'

    name = fields.Char(string=u'Имя преподавателя')
    lesson_id = fields.One2many(comodel_name='kspu.table.lesson', inverse_name='teacher')
    subdep = fields.Char(string=u'Кафедра')
    full_name = fields.Char(string=u'ФИО + Кафедра', compute="_full_name", search="_search_full_name")


    @api.one
    @api.depends('name', 'subdep')
    def _full_name(self):
        self.full_name = u'%s (%s)' % (self.name, self.subdep)

    def _search_full_name(self, operator, value):
        if operator == 'like':
            operator = 'ilike'

        return ['|', '|',
                ('name', operator, value),
                ('subdep', operator, value)
                ]


class Cabinet(models.Model):
    _name = 'kspu.table.cabinet'
    _rec_name = 'name'

    name = fields.Char(string=u'Номер аудитории')
    roominess = fields.Char(string=u'Вместительность')
    lesson_id = fields.One2many(comodel_name='kspu.table.lesson', inverse_name='cabinet')


class Group(models.Model):
    _name = 'kspu.table.group'
    _rec_name = 'name'

    name = fields.Char(string=u'Номер группы', required=True)
    amount = fields.Integer(string=u'Численность группы')
    lesson_id = fields.One2many(comodel_name='kspu.table.lesson', inverse_name='group')
    department = fields.Many2one(string=u'Факультет', comodel_name='kspu.table.department', required=True)
    level = fields.Selection(selection=[
        ('one', u'1 курс'),
        ('two', u'2 курс'),
        ('three', u'3 курс'),
        ('four', u'4 курс'),
        ('five', u'5 курс'),
        ('six', u'6 курс'),
        ('one_master', u'1 курс магистратуры'),
        ('two_master', u'2 курс магистратуры'),
        ('one_postgraduate', u'1 курс аспирантуры'),
        ('two_postgraduate', u'2 курс аспирантуры'),
        ('three_postgraduate', u'3 курс аспирантуры'),
    ], string=u'Курс', required=True)

    @api.model
    def name_search(self, name='', args=None, operator='ilike', limit=100):
        args.append(['department.user_id', '=', self.env.user.id])
        return self._name_search(name, args, operator, limit=limit)


class Department(models.Model):
    _name = 'kspu.table.department'
    _rec_name = 'name'

    name = fields.Char(string=u'Факультет')
    group = fields.One2many(comodel_name='kspu.table.group', inverse_name='department')
    user_id = fields.Many2many(string=u'Инженер расписания', comodel_name='res.users')

    @api.model
    def name_search(self, name='', args=None, operator='ilike', limit=100):
        args.append(['user_id', '=', self.env.user.id])
        return self._name_search(name, args, operator, limit=limit)


class User(models.Model):
    _inherit = 'res.users'

    department = fields.Many2many(string=u'Факультет', comodel_name='kspu.table.department', ondelete='set null',
                                  required=False)

    @api.model
    def create(self, vals):
        return super(User, self).create(vals)


class Slots(models.Model):
    _name = 'kspu.table.slots'

    name = fields.Char(string=u'Временной слот')
    time_start = fields.Float(string=u'Время начала')
    time_end = fields.Float(string=u'Время конца')
    lesson_id = fields.One2many(comodel_name='kspu.table.lesson', inverse_name='lesson_number_show')

    @api.one
    @api.onchange('time_start')
    def check_time_start(self):
        hour_start = int(math.floor(self.time_start))
        minute_start = int(round((self.time_start % 1) * 60))

        print hour_start, minute_start
        return hour_start, minute_start

    @api.one
    @api.onchange('time_end')
    def check_time_end(self):
        hour_end = int(math.floor(self.time_end))
        minute_end = int(round((self.time_end % 1) * 60))

        print hour_end, minute_end
        return hour_end, minute_end