# coding: utf-8
'''
Created on 06.03.2015

@author: v.popov
'''

import json
from bs4 import BeautifulSoup
import re
from uuid import uuid4
from java.text import SimpleDateFormat

from umk._umk_orm import specialityCursor
from datetime import datetime
import tempfile
from common.numbersseries.getNextNo import getNextNoOfSeries
try:
    from ru.curs.showcase.core.jython import JythonDTO
    from ru.curs.showcase.core.selector import ResultSelectorData
    from ru.beta2.extra.gwt.ui.selector.api import DataRecord
    from ru.curs.showcase.app.api import UserMessage, MessageType
except:
    from ru.curs.celesta.showcase import JythonDTO, ResultSelectorData, DataRecord, UserMessage, MessageType
from ru.curs.celesta.showcase.utils import XMLJSONConverter
from nci._nci_orm import personCursor
from edu._edu_orm import educational_groupCursor,\
    edu_group_personsCursor

    

def attachmentUpload(context, main, add, filterinfo, session, elementId, xformsdata, fileName, file):
    u'''Процедура для скачивания файлов в специальную директорию'''
#     session = json.loads(session)    
    tempFile = tempfile.NamedTemporaryFile('w+b', -1, '', 'tmp_%s' % fileName, dir=None, delete=True)
    while 1:
        onebyte = file.read()
        if onebyte == -1:
            break
        else:
            tempFile.write(chr(onebyte))
    tempFile.seek(0)
#     try:
#         param = json.loads(xformsdata)['schema']['context']['@param']
    educationalGroupsImport(context, tempFile, fileName)
#     except Exception as e:
#         context.error(u"Произошла ошибка при загрузке файла: {}".format(e.message))
    tempFile.close()
    

def cardData(context, main=None, add=None, filterinfo=None, session=None, elementId=None):
    u'''Данные для карточки.'''
    # Структура данных
    xformsdata = {"schema": {
                    "context": {
                        "@id": "unique",
                        "@uploadStarted": '1',
                        "@message": u'Выберите, пожалуйста, файл.',
                        "@uploadMessage": u'Пожалуйста ждите. Загрузка может занять некоторое время.',
                        "@successMessage": u'Загрузка файла завершена!',
                        "@mode": add,
                        "@param": "mv",
                        "files1": ''}}}

    xformssettings = {"properties": {
                        "event": {
                            "@name":"single_click",
                            "@linkId": "1",
                            "action": {
                                "#sorted": [
                                    {"main_context": "current"},
                                    {"datapanel": {
                                        "@type": "current",
                                        "@tab": "current",
                                        "element": {"@id":"testGroupsGrid",
                                        "add_context": ""}}}]}}}}


    return JythonDTO(XMLJSONConverter.jsonToXml(json.dumps(xformsdata)), XMLJSONConverter.jsonToXml(json.dumps(xformssettings)))


def cardDataSave(context, main=None, add=None, filterinfo=None, session=None, elementId=None, xformsdata=None):
    session = json.loads(session)['sessioncontext']
    
    
def getTestGroupsJsonFromFile(context, file):
    u'''Загрузка групп по формату Московский врач'''
    html = BeautifulSoup(file, 'html5lib')
    tables = html('table')
    
    options_table = tables[0]
    options_rows = options_table('tr')
    
    test = {
        'speciality': u'',
        'control_date': u''}
    
    matching_numbers = {
        1: 'speciality',  
        2: 'control_date'}
    
    for i, row in enumerate(options_rows):
        index = i + 1        
        td = row('td')
        param = cleanString(' '.join(td[2].stripped_strings))
        if not param:
            context.error(u'Отсутствует параметр №{}'.format(i))
        else:
            try:
                test[matching_numbers[index]] = param
            except:
                pass
        
    groups = list()
    group = dict()
    groups_table = tables[1]
    groups_rows = groups_table('tr')

    for row in groups_rows:
        td = row('td')
        td1 = cleanString(u' '.join(td[0].stripped_strings))
        if td1 == u'Время':
            if group:
                groups.append(group)
            group = dict()
            group['persons'] = []
            time = cleanString(u' '.join(td[1].stripped_strings))
            if len(time) < 5:
                time = '0{}'.format(time)
            group['name'] = u'{}, {} {}'.format(test['speciality'], test['control_date'], time)
            group['time'] = time
        elif td1:
            person = dict()
            person['surname'] = cleanString(u' '.join(td[1].stripped_strings))
            person['name'] = cleanString(u' '.join(td[2].stripped_strings))
            person['patronymic'] = cleanString(u' '.join(td[3].stripped_strings))
            person['phone'] = cleanString(u' '.join(td[4].stripped_strings))
            if group:
                group['persons'].append(person)
        elif group:
            groups.append(group)
            group = dict()
    
    if group:
        groups.append(group)
        group = dict()
    test['groups'] = groups
    
    return test


def cleanString(s):
    text = u''
    ss = s.replace(u' ', '')
    if ss:
        pattern = re.compile(r'[\t\n\r\f\v]+')
        text = re.sub(pattern, '', s)
        text =  (u' '.join(text.split())).strip()
    return text


def educationalGroupsImport(context, file, filename, param='mv'):
    TEST_JSON_FUNCTIONS = {
        "mv": getTestGroupsJsonFromFile}
    
    test = TEST_JSON_FUNCTIONS[param](context, file)
    
    speciality = test['speciality']
    specialityCur = specialityCursor(context)
    specialityCur.setRange('name', speciality)
    if not specialityCur.tryFirst():
        context.error(u'Неизвестная специальность - {}'.format(speciality))
        
    speciality_id = specialityCur.uid
    specialityCur.close()
    
    groupCur = educational_groupCursor(context)
    groupCur.setRange('speciality', speciality_id)
    
    group_personsCur = edu_group_personsCursor(context)
    
    personCur = personCursor(context)
    
    messages = []
    
    for group in test['groups']:
        group_name = group['name']
        
        groupCur.setRange('speciality', speciality_id)
        groupCur.setRange('group_name', group_name)
        if groupCur.tryFirst():
            messages.append(u'Группа с именем "{}" уже существует'.format(group_name))
        else:
            groupCur.clear()
            groupCur.speciality = speciality_id
            groupCur.group_name = group_name
            groupCur.create_date = datetime.now()
            groupCur.control_date = datetime.strptime(test['control_date'], "%d.%m.%Y")
            groupCur.insert()
            
            group_id = groupCur.group_id
            
            for person in group['persons']:            
                surname = person['surname'] 
                name = person['name'] 
                patronymic = person['patronymic'] 
                
#                 personCur.setRange('surname', surname)
#                 personCur.setRange('name', name)
#                 personCur.setRange('patronymic', patronymic)
#                 if personCur.tryFirst():
#                     person_id = personCur.uid
#                 else:
                personCur.clear()
                personCur.uid = getNextNoOfSeries(context, 'persons')
                personCur.surname = surname 
                personCur.name = name 
                personCur.patronymic = patronymic
                personCur.fullname = u'{} {}{}'.format(surname, name, u' {}'.format(patronymic) if patronymic else u'') 
                personCur.phone = person['phone']
                personCur.insert()
                    
                person_id = personCur.uid
                
                group_personsCur.group_person_id = None
                group_personsCur.group_id = group_id
                group_personsCur.person_id = person_id
                group_personsCur.insert()
                
    group_personsCur.close()            
    personCur.close()
    groupCur.close()
    return messages