import random
import string
import uuid as uuid_lib
from datetime import datetime, timedelta
from flask import Blueprint, request, jsonify
from flask_jwt_extended import jwt_required, get_jwt_identity
from extensions import db
from models import User, Paciente, ConviteVinculo, Vinculo, Palavra, PendenciaAprovacao
from subscription import status_assinatura

vinculos_bp = Blueprint('vinculos', __name__)

def get_user():
    return User.query.filter_by(uuid=get_jwt_identity()).first()

def gerar_codigo():
    """Gera um código de 8 caracteres, evitando letras/números ambíguos (0/O, 1/I)."""
    alfabeto = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'
    return ''.join(random.choices(alfabeto, k=8))

@vinculos_bp.route('/gerar-convite', methods=['POST'])
@jwt_required()
def gerar_convite():
    user = get_user()
    sub = status_assinatura(user)

    if user.plano != 'terapeuta' or not sub['pode_usar_premium']:
        return jsonify({'erro': 'Recurso disponível apenas para contas de terapeuta ativas'}), 403

    data = request.get_json() or {}
    paciente_uuid = data.get('paciente_uuid')

    paciente = Paciente.query.filter_by(uuid=paciente_uuid, user_id=user.id).first()
    if not paciente:
        return jsonify({'erro': 'Perfil não encontrado'}), 404

    codigo = gerar_codigo()
    while ConviteVinculo.query.filter_by(codigo=codigo).first():
        codigo = gerar_codigo()

    convite = ConviteVinculo(
        codigo=codigo,
        terapeuta_paciente_id=paciente.id,
        expira_em=datetime.utcnow() + timedelta(days=7)
    )
    db.session.add(convite)
    db.session.commit()

    return jsonify({'codigo': codigo, 'expira_em': convite.expira_em.isoformat()}), 201

@vinculos_bp.route('/resgatar-convite', methods=['POST'])
@jwt_required()
def resgatar_convite():
    user = get_user()
    data = request.get_json() or {}
    codigo = (data.get('codigo') or '').strip().upper()
    paciente_uuid = data.get('paciente_uuid')

    if not codigo or not paciente_uuid:
        return jsonify({'erro': 'Código e perfil são obrigatórios'}), 400

    paciente_familia = Paciente.query.filter_by(uuid=paciente_uuid, user_id=user.id).first()
    if not paciente_familia:
        return jsonify({'erro': 'Perfil não encontrado'}), 404

    vinculo_existente = Vinculo.query.filter_by(familia_paciente_id=paciente_familia.id, ativo=True).first()
    if vinculo_existente:
        return jsonify({'erro': 'Este perfil já está vinculado a um terapeuta'}), 400

    convite = ConviteVinculo.query.filter_by(codigo=codigo, usado=False).first()
    if not convite:
        return jsonify({'erro': 'Código inválido ou já utilizado'}), 400

    if convite.expira_em and convite.expira_em < datetime.utcnow():
        return jsonify({'erro': 'Código expirado. Peça um novo ao terapeuta.'}), 400

    vinculo = Vinculo(
        terapeuta_paciente_id=convite.terapeuta_paciente_id,
        familia_paciente_id=paciente_familia.id,
        ativo=True
    )
    db.session.add(vinculo)

    convite.usado = True
    db.session.commit()

    return jsonify({
        'ok': True,
        'nome_terapeuta_perfil': convite.terapeuta_paciente.nome
    }), 201

@vinculos_bp.route('/desvincular/<uuid_paciente>', methods=['POST'])
@jwt_required()
def desvincular(uuid_paciente):
    user = get_user()
    paciente = Paciente.query.filter_by(uuid=uuid_paciente, user_id=user.id).first()
    if not paciente:
        return jsonify({'erro': 'Perfil não encontrado'}), 404

    vinculo = Vinculo.query.filter(
        db.or_(
            Vinculo.familia_paciente_id == paciente.id,
            Vinculo.terapeuta_paciente_id == paciente.id
        ),
        Vinculo.ativo == True
    ).first()

    if not vinculo:
        return jsonify({'erro': 'Nenhum vínculo ativo encontrado'}), 404

    vinculo.ativo = False
    db.session.commit()

    return jsonify({'ok': True}), 200

@vinculos_bp.route('/status/<uuid_paciente>', methods=['GET'])
@jwt_required()
def status_vinculo(uuid_paciente):
    """Informa se um perfil está vinculado, e a que papel (terapeuta ou família)."""
    user = get_user()
    paciente = Paciente.query.filter_by(uuid=uuid_paciente, user_id=user.id).first()
    if not paciente:
        return jsonify({'erro': 'Perfil não encontrado'}), 404

    vinculo = Vinculo.query.filter(
        db.or_(
            Vinculo.familia_paciente_id == paciente.id,
            Vinculo.terapeuta_paciente_id == paciente.id
        ),
        Vinculo.ativo == True
    ).first()

    if not vinculo:
        return jsonify({'vinculado': False}), 200

    papel = 'terapeuta' if vinculo.terapeuta_paciente_id == paciente.id else 'familia'
    outro_nome = vinculo.familia_paciente.nome if papel == 'terapeuta' else vinculo.terapeuta_paciente.nome

    return jsonify({
        'vinculado': True,
        'papel': papel,
        'outro_nome': outro_nome,
        'vinculo_id': vinculo.id,
        'ultima_sincronizacao_em': vinculo.ultima_sincronizacao_em.isoformat() if vinculo.ultima_sincronizacao_em else None,
        'ultimas_palavras_criadas': (vinculo.ultimas_palavras_criadas or '').split('|') if vinculo.ultimas_palavras_criadas else [],
        'ultimas_palavras_atualizadas': (vinculo.ultimas_palavras_atualizadas or '').split('|') if vinculo.ultimas_palavras_atualizadas else [],
    }), 200

@vinculos_bp.route('/vinculos-terapeuta', methods=['GET'])
@jwt_required()
def listar_vinculos_terapeuta():
    """Lista todos os vínculos ativos de todos os perfis do terapeuta logado."""
    user = get_user()

    pacientes_ids = [p.id for p in Paciente.query.filter_by(user_id=user.id).all()]
    vinculos = Vinculo.query.filter(
        Vinculo.terapeuta_paciente_id.in_(pacientes_ids),
        Vinculo.ativo == True
    ).all()

    return jsonify([{
        'vinculo_id': v.id,
        'paciente_terapeuta_uuid': v.terapeuta_paciente.uuid,
        'paciente_terapeuta_nome': v.terapeuta_paciente.nome,
        'nome_familia': v.familia_paciente.nome,
    } for v in vinculos]), 200

@vinculos_bp.route('/pendencias/<vinculo_id>', methods=['GET'])
@jwt_required()
def listar_pendencias(vinculo_id):
    """Lista as mudanças da família aguardando revisão do terapeuta."""
    user = get_user()

    vinculo = Vinculo.query.filter_by(id=vinculo_id, ativo=True).first()
    if not vinculo:
        return jsonify({'erro': 'Vínculo não encontrado'}), 404

    terapeuta_paciente = Paciente.query.filter_by(id=vinculo.terapeuta_paciente_id, user_id=user.id).first()
    if not terapeuta_paciente:
        return jsonify({'erro': 'Sem permissão para este vínculo'}), 403

    pendencias = PendenciaAprovacao.query.filter_by(vinculo_id=vinculo.id, status='pendente').order_by(
        PendenciaAprovacao.criado_em.asc()
    ).all()

    return jsonify([{
        'id': p.id,
        'tipo': p.tipo,
        'texto': p.texto,
        'emoji': p.emoji,
        'imagem': p.imagem,
        'categoria': p.categoria,
        'criado_em': p.criado_em.isoformat(),
    } for p in pendencias]), 200

@vinculos_bp.route('/pendencias/resolver', methods=['POST'])
@jwt_required()
def resolver_pendencias():
    """
    Aprova ou rejeita uma ou mais pendências.
    Payload: { "aprovar_ids": [1, 2], "rejeitar": [{"id": 3, "motivo": "..."}] }
    """
    user = get_user()
    data = request.get_json() or {}
    aprovar_ids = data.get('aprovar_ids', [])
    rejeitar = data.get('rejeitar', [])

    def pertence_ao_terapeuta(pendencia):
        vinculo = Vinculo.query.get(pendencia.vinculo_id)
        if not vinculo:
            return False
        terapeuta_paciente = Paciente.query.filter_by(id=vinculo.terapeuta_paciente_id, user_id=user.id).first()
        return terapeuta_paciente is not None

    # Aprovações: aplica a mudança de verdade na prancha da família
    for pid in aprovar_ids:
        pendencia = PendenciaAprovacao.query.filter_by(id=pid, status='pendente').first()
        if not pendencia or not pertence_ao_terapeuta(pendencia):
            continue

        vinculo = Vinculo.query.get(pendencia.vinculo_id)
        familia_paciente_id = vinculo.familia_paciente_id
        terapeuta_paciente_id = vinculo.terapeuta_paciente_id

        if pendencia.tipo == 'adicionar':
            palavra_familia = Palavra.query.filter_by(
                sync_id=pendencia.sync_id, paciente_id=familia_paciente_id
            ).first()
            ja_existe_no_modelo = Palavra.query.filter_by(
                sync_id=pendencia.sync_id, paciente_id=terapeuta_paciente_id
            ).first()
            if palavra_familia and not ja_existe_no_modelo:
                ordem_modelo = Palavra.query.filter_by(paciente_id=terapeuta_paciente_id).count()
                espelho = Palavra(
                    texto=palavra_familia.texto, emoji=palavra_familia.emoji,
                    imagem=palavra_familia.imagem, categoria=palavra_familia.categoria,
                    ordem=ordem_modelo, sync_id=pendencia.sync_id,
                    paciente_id=terapeuta_paciente_id
                )
                db.session.add(espelho)

        elif pendencia.tipo == 'editar':
            palavra_familia = Palavra.query.filter_by(
                sync_id=pendencia.sync_id, paciente_id=familia_paciente_id
            ).first()
            palavra_modelo = Palavra.query.filter_by(
                sync_id=pendencia.sync_id, paciente_id=terapeuta_paciente_id
            ).first()
            if palavra_familia and palavra_modelo:
                palavra_modelo.texto = palavra_familia.texto
                palavra_modelo.categoria = palavra_familia.categoria

        elif pendencia.tipo == 'remover':
            palavra_atual = Palavra.query.filter_by(
                sync_id=pendencia.sync_id, paciente_id=familia_paciente_id
            ).first()
            if palavra_atual:
                db.session.delete(palavra_atual)

            palavra_modelo = Palavra.query.filter_by(
                sync_id=pendencia.sync_id, paciente_id=terapeuta_paciente_id
            ).first()
            if palavra_modelo:
                db.session.delete(palavra_modelo)

        pendencia.status = 'aprovada'
        pendencia.resolvido_em = datetime.utcnow()

    # Rejeições: reverte a mudança e registra o motivo
    for item in rejeitar:
        pid = item.get('id')
        motivo = (item.get('motivo') or '').strip()
        pendencia = PendenciaAprovacao.query.filter_by(id=pid, status='pendente').first()
        if not pendencia or not pertence_ao_terapeuta(pendencia):
            continue

        vinculo = Vinculo.query.get(pendencia.vinculo_id)
        familia_paciente_id = vinculo.familia_paciente_id

        if pendencia.tipo == 'adicionar':
            palavra_atual = Palavra.query.filter_by(
                sync_id=pendencia.sync_id, paciente_id=familia_paciente_id
            ).first()
            if palavra_atual:
                db.session.delete(palavra_atual)  # remove o que a família tinha adicionado

        elif pendencia.tipo == 'editar':
            palavra_atual = Palavra.query.filter_by(
                sync_id=pendencia.sync_id, paciente_id=familia_paciente_id
            ).first()
            if palavra_atual:
                # Reverte para o estado anterior guardado na pendência
                palavra_atual.texto = pendencia.texto
                palavra_atual.categoria = pendencia.categoria

        elif pendencia.tipo == 'remover':
            existe_ainda = Palavra.query.filter_by(
                sync_id=pendencia.sync_id, paciente_id=familia_paciente_id
            ).first()
            if not existe_ainda:
                # Recria a palavra que a família tinha apagado
                nova = Palavra(
                    texto=pendencia.texto, emoji=pendencia.emoji, imagem=pendencia.imagem,
                    categoria=pendencia.categoria, ordem=999, sync_id=pendencia.sync_id,
                    paciente_id=familia_paciente_id
                )
                db.session.add(nova)

        pendencia.status = 'rejeitada'
        pendencia.motivo_rejeicao = motivo
        pendencia.resolvido_em = datetime.utcnow()

    db.session.commit()
    return jsonify({'ok': True}), 200

@vinculos_bp.route('/notificacoes-rejeicao/<uuid_paciente>', methods=['GET'])
@jwt_required()
def notificacoes_rejeicao(uuid_paciente):
    """A família consulta quais mudanças dela foram rejeitadas recentemente, e por quê."""
    user = get_user()
    paciente = Paciente.query.filter_by(uuid=uuid_paciente, user_id=user.id).first()
    if not paciente:
        return jsonify({'erro': 'Perfil não encontrado'}), 404

    vinculo = Vinculo.query.filter_by(familia_paciente_id=paciente.id, ativo=True).first()
    if not vinculo:
        return jsonify([]), 200

    rejeitadas = PendenciaAprovacao.query.filter_by(
        vinculo_id=vinculo.id, status='rejeitada'
    ).order_by(PendenciaAprovacao.resolvido_em.desc()).limit(10).all()

    return jsonify([{
        'id': p.id,
        'tipo': p.tipo,
        'texto': p.texto,
        'motivo': p.motivo_rejeicao,
        'resolvido_em': p.resolvido_em.isoformat() if p.resolvido_em else None,
    } for p in rejeitadas]), 200

@vinculos_bp.route('/sincronizar/<vinculo_id>', methods=['POST'])
@jwt_required()
def sincronizar(vinculo_id):
    """O terapeuta envia o estado atual do modelo para o perfil da família vinculada."""
    user = get_user()

    vinculo = Vinculo.query.filter_by(id=vinculo_id, ativo=True).first()
    if not vinculo:
        return jsonify({'erro': 'Vínculo não encontrado'}), 404

    terapeuta_paciente = Paciente.query.filter_by(id=vinculo.terapeuta_paciente_id, user_id=user.id).first()
    if not terapeuta_paciente:
        return jsonify({'erro': 'Você não tem permissão para sincronizar este vínculo'}), 403

    familia_paciente = vinculo.familia_paciente

    palavras_modelo = Palavra.query.filter_by(paciente_id=terapeuta_paciente.id).all()
    todas_palavras_familia = Palavra.query.filter_by(paciente_id=familia_paciente.id).all()
    palavras_familia_por_sync = {p.sync_id: p for p in todas_palavras_familia if p.sync_id}
    palavras_familia_por_texto = {p.texto.strip().lower(): p for p in todas_palavras_familia}

    criadas = []
    atualizadas = []
    ordem_atual = len(todas_palavras_familia)

    for pm in palavras_modelo:
        if not pm.sync_id:
            pm.sync_id = str(uuid_lib.uuid4())

        existente = palavras_familia_por_sync.get(pm.sync_id)

        # Se não achou por sync_id, tenta achar uma palavra igual pelo texto
        # (evita duplicar palavras do vocabulário núcleo que já existiam antes do vínculo)
        if not existente:
            existente = palavras_familia_por_texto.get(pm.texto.strip().lower())
            if existente and not existente.sync_id:
                existente.sync_id = pm.sync_id  # a partir de agora, essa palavra passa a ser rastreada

        if existente:
            # Atualiza apenas se o texto/categoria/pictograma do modelo mudou
            mudou = (existente.texto != pm.texto or existente.categoria != pm.categoria or existente.imagem != pm.imagem)
            if mudou:
                existente.texto = pm.texto
                existente.emoji = pm.emoji
                existente.categoria = pm.categoria
                # Preserva foto pessoal que a família já tenha colocado (não sobrescreve com pictograma do terapeuta)
                if not (existente.imagem and existente.imagem != pm.imagem and 'static.arasaac.org' not in (existente.imagem or '')):
                    existente.imagem = pm.imagem
                atualizadas.append(pm.texto)
        else:
            nova = Palavra(
                texto=pm.texto,
                emoji=pm.emoji,
                imagem=pm.imagem,
                categoria=pm.categoria,
                ordem=ordem_atual,
                sync_id=pm.sync_id,
                paciente_id=familia_paciente.id
            )
            db.session.add(nova)
            ordem_atual += 1
            criadas.append(pm.texto)

    vinculo.ultima_sincronizacao_em = datetime.utcnow()
    vinculo.ultimas_palavras_criadas = '|'.join(criadas)
    vinculo.ultimas_palavras_atualizadas = '|'.join(atualizadas)

    db.session.commit()

    return jsonify({
        'ok': True,
        'palavras_criadas': criadas,
        'palavras_atualizadas': atualizadas,
    }), 200

