import logging
import re
import traceback
from datetime import datetime

from portal.base import UploadHandler, ContractCreator, REGEX_EMAIL
from portal.model import db, UploadRegular


class UploadHandlerRegular(UploadHandler):

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.contract_creator = ContractCreator(base_path=self.get_uploads_subdir('contracts'),
                                                    template_path='contract/regular.html')

    def generate_upload_contract_pdf(self, upload_metadata):
        base = self.get_uploads_subdir('contracts')
        form_data = upload_metadata['form_data']

        files_table_str = []
        for file_name in upload_metadata['file_names']:
            files_table_str.append('<tr><td style="text-align: center;">')
            files_table_str.append(file_name)
            files_table_str.append('</td></tr>')
        files_table_str = ''.join(files_table_str)

        data = {
            'ime_priimek': form_data['ime'],
            'naslov': form_data.get('naslov', ''),
            'posta': form_data.get('posta', ''),
            'kontakt_narocnik': self.config['CONTRACT_CLIENT_CONTACT'],
            'kontakt_imetnikpravic': form_data['ime'],
            'files_table_str': files_table_str
            }

        self.contract_creator.create_pdf(upload_metadata['contract_file'], data)

    @staticmethod
    def store_metadata(upload_metadata, corpus_name):
        timestamp = datetime.fromtimestamp(upload_metadata['timestamp'])
        form_data = upload_metadata['form_data']
        file_hashes = upload_metadata['file_hashes_dict']
        sorted_f_hashes = list(file_hashes.values())
        sorted_f_hashes.sort()
        
        try:
            model_obj = UploadRegular(
                    upload_hash=upload_metadata['upload_id'],
                    timestamp=timestamp,
                    name=form_data['ime'],
                    org=form_data.get('podjetje'),
                    address=form_data.get('naslov'),
                    zipcode=form_data.get('posta'),
                    email=form_data['email'],
                    file_contract=upload_metadata['contract_file'],
                    upload_file_hashes=sorted_f_hashes,
                    corpus_name=corpus_name
                   )

            db.session.add(model_obj)
            db.session.commit()
        except Exception:
            traceback.print_exc()

 
    def handle_upload(self, request, corpus_name):
        err = self.check_upload_request(request)
        if err:
            return err, 400

        err = self.check_form(request.form)
        if err:
            return err, 400

        # Parse request.
        upload_metadata = self.extract_upload_metadata(corpus_name, request)

        logging.info('Upload with id "{}" supplied form data: {}'.format(upload_metadata['upload_id'],
            str(upload_metadata['form_data'])))

        # Generate contract PDF file based on the uploads metadata.
        self.generate_upload_contract_pdf(upload_metadata)

        # Store uploaded files to disk.
        self.store_datafiles(request.files, upload_metadata)

        # Store metadata to database.
        self.store_metadata(upload_metadata, corpus_name)

        # Send confirmation mail along with the contract to the submitted email address.
        self.send_confirm_mail(upload_metadata, attach_contract_file=True)

        return 'Uspešno ste oddali datotek(e). Št. datotek: {}'.format(len(request.files))

    @staticmethod
    def check_form(form):
        ime = form.get('ime')
        podjetje = form.get('podjetje')
        naslov = form.get('naslov')
        posta = form.get('posta')
        email = form.get('email')
        telefon = form.get('telefon')

        if not ime:
            return 'Prazno polje za ime.'
        if len(ime) > 100:
            return 'Predolgo ime.'

        if podjetje and len(podjetje) > 100:
            return 'Predolgo ime institucije.'

        if not email:
            return 'Prazno polje za elektronsko pošto.'
        if len(email) > 100:
            return 'Predolgi email naslov'
        elif not re.search(REGEX_EMAIL, email):
            return 'Email napačnega formata.'

        if telefon and len(telefon) > 100:
            return 'Predolga telefonska št.'

        if naslov and len(naslov) > 100:
            return 'Predolg  naslov.'

        if posta and len(posta) > 100:
            return 'Predolga pošta'

        return None