#!/usr/bin/env python

import sqlite3
import click
from peewee import *

if __name__ == '__main__':
    import os, sys
    parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    sys.path.insert(0, parent_dir)

from controllers import util
from conf import DATABASE, __version__
from settings import log, PATH_CP


database = DATABASE
class BaseModel(Model):
    class Meta:
        database = database


def connect():
    global database
    database.connect()
    log.info('Conectado a la BD...')
    return


class Configuration(BaseModel):
    key = FixedCharField(max_length=50)
    value = FixedCharField(max_length=100)

    class Meta:
        order_by = ('key',)
        indexes = (
            (('key', 'value'), True),
        )


class Tags(BaseModel):
    tag = FixedCharField(max_length=25, index=True)

    class Meta:
        order_by = ('tag',)


class Users(BaseModel):
    username = CharField(max_length=50, unique=True)
    first_name = CharField(max_length=50, default='')
    last_name = CharField(max_length=50, default='')
    email = CharField(max_length=200, default='')
    password = CharField(max_length=100)
    is_superuser = BooleanField(default=False)
    is_admin = BooleanField(default=False)
    is_staff = BooleanField(default=False)
    is_active = BooleanField(default=True)
    date_joined = DateTimeField(default=util.now)
    last_login = DateTimeField(null=True)

    def __str__(self):
        t = '{} {} ({})'
        return t.format(self.first_name, self.last_name, self.username)

    class Meta:
        order_by = ('username',)


class Clients(BaseModel):
    person_type = IntegerField(default=0)
    rfc = FixedCharField(max_length=13, index=True)
    name = CharField(max_length=1000, index=True)
    street = FixedCharField(max_length=200, default='')
    num_ext = FixedCharField(max_length=25, default='')
    num_int = FixedCharField(max_length=25, default='')
    postal_code = FixedCharField(max_length=15, default='')
    colonia = FixedCharField(max_length=100, default='')
    municipio = FixedCharField(max_length=100, default='')
    state = FixedCharField(max_length=100, default='')
    country = FixedCharField(max_length=100, default='')
    conditions_pay = FixedCharField(max_length=250, default='')
    days_pay = IntegerField(default=0)
    business_days = BooleanField(default=False)
    is_active = BooleanField(default=True)
    commercial_name = CharField(max_length=1000, default='')
    phones = CharField(max_length=500, default='')
    web_page = CharField(max_length=500, default='')
    invoice_email = CharField(max_length=500, default='')
    is_client = BooleanField(default=False)
    is_supplier = BooleanField(default=False)
    is_ong = BooleanField(default=False)
    account_client = FixedCharField(max_length=100, default='')
    account_supplier = FixedCharField(max_length=100, default='')
    notes = CharField(max_length=5000)

    def __str__(self):
        t = '{} ({})'
        return t.format(self.name, self.rfc)

    class Meta:
        order_by = ('name',)
        indexes = (
            (('rfc', 'name'), True),
        )


class ClientsTags(BaseModel):
    client = ForeignKeyField(Clients)
    tag = ForeignKeyField(Tags)

    class Meta:
        indexes = (
            (('client', 'tag'), True),
        )


def authenticate(username, password):
    data = {'login': False, 'msg': 'No Autorizado', 'user': ''}
    try:
        obj = Users.get(Users.username==username, Users.is_active==True)
    except Users.DoesNotExist:
        return data

    if not util.validate_password(obj.password, password):
        return data

    obj.last_login = util.now()
    obj.save()
    data['msg'] = ''
    data['login'] = True
    data['user'] = str(obj)
    return data


def get_partners(values):
    if values:
        id = int(values['id'])
        row = Clients.select().where(Clients.id==id).dicts()[0]
        return row

    rows = Clients.select(Clients.id, Clients.rfc, Clients.name).dicts()
    return {'ok': True, 'rows': tuple(rows)}


def new_partner(values):
    fields = util.clean(values)
    fields['rfc'] = fields['rfc'].upper()
    obj = Clients.create(**fields)
    row = {
        'id': obj.id,
        'cia': obj.cia,
        'rfc': obj.rfc,
        'name': obj.name,
    }
    data = {'ok': True, 'row': row, 'new': True}
    return data


def get_cp(cp):
    con = sqlite3.connect(PATH_CP)
    cursor = con.cursor()
    sql = """
        SELECT colonia, municipio, estado
        FROM colonias, municipios, estados
        WHERE colonias.id_municipio=municipios.id
            AND municipios.id_estado=estados.id
            AND cp=?
        ORDER BY colonia"""
    cursor.execute(sql, (cp,))
    rows = cursor.fetchall()
    cursor.close()
    con.close()

    data = {}
    if rows:
        data = {
            'estado': rows[0][2],
            'municipio': rows[0][1],
        }
        if len(rows) == 1:
            data['colonia'] = rows[0][0]
        else:
            data['colonia'] = [r[0] for r in rows]
    return data


def _init_values():
    data = (
        {'key': 'version', 'value': __version__},
        {'key': 'rfc_publico', 'value': 'XAXX010101000'},
        {'key': 'rfc_extranjero', 'value': 'XEXX010101000'},
    )
    for row in data:
        try:
            Configuration.create(**row)
        except IntegrityError:
            pass
    log.info('Valores iniciales insertados...')
    return


def create_tables():
    connect()
    tables = [Configuration, Tags, Users, Clients, ClientsTags]
    database.create_tables(tables, True)
    log.info('Tablas creadas correctamente...')
    _init_values()
    return


def migrate_tables():
    connect()
    log.info('Tablas migradas correctamente...')
    return


def create_superuser():
    connect()
    username = input('Introduce el nuevo nombre para el superusuario: ').strip()
    if not username:
        msg = 'El nombre de usuario es requerido'
        log.erro(msg)
        return
    ok, password = util.get_pass()
    if not ok:
        log.error(password)
        return
    try:
        obj = Users.create(username=username, password=password, is_superuser=True)
    except IntegrityError:
        msg = 'El usuario ya existe'
        log.error(msg)
        return

    log.info('SuperUsuario creado correctamente...')
    return


def change_password():
    connect()
    username = input('Introduce el nombre de usuario: ').strip()
    if not username:
        msg = 'El nombre de usuario es requerido'
        log.error(msg)
        return

    try:
        obj = Users.get(username=username)
    except Users.DoesNotExist:
        msg = 'El usuario no existe'
        log.error(msg)
        return

    ok, password = util.get_pass()
    if not ok:
        log.error(password)
        return

    obj.password = password
    obj.save()

    log.info('Contraseña cambiada correctamente...')
    return


CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
help_create_tables = 'Crea las tablas en la base de datos'
help_migrate_db = 'Migra las tables en la base de datos'
help_superuser = 'Crea un nuevo super usuario'
help_change_pass = 'Cambia la contraseña a un usuario'

@click.command(context_settings=CONTEXT_SETTINGS)
@click.option('-bd', '--iniciar-bd',help=help_create_tables,
    is_flag=True, default=False)
@click.option('-m', '--migrar-bd', help=help_migrate_db,
    is_flag=True, default=False)
@click.option('-ns', '--nuevo-superusuario', help=help_superuser,
    is_flag=True, default=False)
@click.option('-cc', '--cambiar-contraseña', help=help_change_pass,
    is_flag=True, default=False)
def main(iniciar_bd, migrar_bd, nuevo_superusuario, cambiar_contraseña):
    opt = locals()

    if opt['iniciar_bd']:
        create_tables()
        sys.exit(0)

    if opt['migrar_bd']:
        migrate_tables()
        sys.exit(0)

    if opt['nuevo_superusuario']:
        create_superuser()
        sys.exit(0)

    if opt['cambiar_contraseña']:
        change_password()
    return


if __name__ == '__main__':
    main()