app.py

"""
IndraLex - Asistente de Cumplimiento Normativo Peruano
========================================================
Desarrollado para proyectos Indra en Perú

CONFIGURACIÓN INICIAL:
1. Crear archivo .env con: OPENAI_API_KEY=tu_api_key_aqui
2. Crear carpeta 'legislacion' y colocar PDFs de normativas peruanas
3. Instalar: pip install streamlit langchain langchain_openai langchain-community openai pypdf faiss-cpu python-dotenv
4. Ejecutar: streamlit run app.py
"""

import os
import hashlib
from pathlib import Path
from typing import List, Optional, Dict
import streamlit as st
from dotenv import load_dotenv
from datetime import datetime

try:
    # Intenta usar Streamlit secrets si están disponibles
    if hasattr(st, 'secrets') and "OPENAI_API_KEY" in st.secrets:
        os.environ["OPENAI_API_KEY"] = st.secrets["OPENAI_API_KEY"]
    else:
        # Usa .env para desarrollo local
        load_dotenv()
except:
    # Si hay cualquier error, usa .env
    load_dotenv()

# Importaciones de LangChain
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
from langchain.schema import Document

# =====================================================
# CONFIGURACIÓN Y CONSTANTES
# =====================================================
LEGISLACION_DIR = "legislacion"
CACHE_DIR = "cache"
FAISS_INDEX_DIR = "faiss_index"
PDF_HASH_FILE = "pdf_hash.txt"

# Configuración de chunks
CHUNK_SIZE = 1500  # Aumentado para capturar artículos completos
CHUNK_OVERLAP = 300

# Configuración del modelo
MODEL_NAME = "gpt-4o-mini"
TEMPERATURE = 0.2  # Más determinístico
MAX_TOKENS = 3000  # Más tokens para análisis detallado

# =====================================================
# PROMPT TEMPLATE ESPECIALIZADO PARA PERÚ
# =====================================================
PROMPT_TEMPLATE = """Eres IndraLex, un asistente especializado en normativas peruanas para proyectos tecnológicos de Indra.
Tu conocimiento incluye:
- Ley 29733: Ley de Protección de Datos Personales
- DL 1412: Decreto Legislativo de Gobierno Digital
- Circulares SBS: Normativas bancarias y de ciberseguridad
- Ley 30096: Ley de Delitos Informáticos
- Ley 27269: Ley de Firmas y Certificados Digitales
- Normativas de SEGDI, PCM, RENIEC, SUNAT, ONPE

Contexto de los documentos:
{context}

Descripción del proyecto:
{question}

INSTRUCCIONES ESPECÍFICAS:
1. Identifica TODAS las leyes peruanas aplicables al proyecto
2. Para cada normativa relevante proporciona:
   - Número de Ley/Decreto y año
   - Artículos específicos aplicables
   - Explicación clara de las obligaciones
   - Multas o sanciones por incumplimiento (si las menciona)
   - Entidad reguladora responsable (SBS, PCM, SEGDI, etc.)

3. Considera aspectos específicos del contexto peruano:
   - Requisitos de la Autoridad Nacional de Protección de Datos Personales
   - Estándares de interoperabilidad del Estado Peruano
   - Lineamientos de SEGDI para gobierno digital
   - Regulaciones sectoriales (SBS para banca, OSIPTEL para telco, etc.)

FORMATO DE RESPUESTA:

📋 **ANÁLISIS DE CUMPLIMIENTO NORMATIVO - PERÚ**

🏛️ **Marco Legal Aplicable:**

[Lista cada ley/decreto con su nombre completo]

📑 **Análisis Detallado por Normativa:**

[Para cada normativa:]
**[Número y Nombre de la Ley]**
- 📌 Artículos aplicables: [lista específica]
- 📝 Obligaciones: [descripción clara]
- ⚠️ Sanciones: [si aplica]
- 🏢 Entidad supervisora: [nombre]

🔧 **Requisitos Técnicos Identificados:**

[Lista de implementaciones técnicas requeridas]

✅ **Plan de Cumplimiento Recomendado:**

[Pasos específicos para cumplir con la normativa peruana]

⚖️ **Entidades Reguladoras a Considerar:**

[Lista de organismos peruanos relevantes]

📢 **Nota:** Este análisis está basado en la legislación peruana vigente. Para proyectos del sector público, verificar adicionalmente los lineamientos específicos de SEGDI y PCM.

Respuesta:"""

# =====================================================
# FUNCIONES AUXILIARES
# =====================================================

def ensure_directories():
    """Crea los directorios necesarios si no existen"""
    Path(LEGISLACION_DIR).mkdir(exist_ok=True)
    Path(CACHE_DIR).mkdir(exist_ok=True)
    Path(FAISS_INDEX_DIR).mkdir(exist_ok=True)

def get_pdf_files() -> List[Path]:
    """Obtiene todos los archivos PDF de la carpeta legislacion"""
    legislacion_path = Path(LEGISLACION_DIR)
    if not legislacion_path.exists():
        st.error(f"⚠️ La carpeta '{LEGISLACION_DIR}' no existe. Créala y añade las normativas peruanas.")
        return []

    pdf_files = list(legislacion_path.glob("*.pdf"))
    if not pdf_files:
        st.warning(f"📁 No se encontraron PDFs en '{LEGISLACION_DIR}'. Añade las leyes peruanas.")
    return pdf_files

def identify_law_type(filename: str) -> str:
    """Identifica el tipo de ley basado en el nombre del archivo"""
    filename_lower = filename.lower()
    if "29733" in filename or "datos" in filename_lower:
        return "Ley de Protección de Datos Personales"
    elif "1412" in filename or "gobierno digital" in filename_lower:
        return "Ley de Gobierno Digital"
    elif "sbs" in filename_lower or "140" in filename:
        return "Circular SBS - Ciberseguridad"
    elif "30096" in filename or "delitos" in filename_lower:
        return "Ley de Delitos Informáticos"
    elif "27269" in filename or "firma" in filename_lower:
        return "Ley de Firmas Digitales"
    else:
        return "Normativa Peruana"

def calculate_pdfs_hash(pdf_files: List[Path]) -> str:
    """Calcula un hash único basado en los PDFs"""
    hash_input = ""
    for pdf_file in sorted(pdf_files):
        hash_input += f"{pdf_file.name}:{pdf_file.stat().st_size}:"
    return hashlib.md5(hash_input.encode()).hexdigest()

def is_cache_valid(pdf_files: List[Path]) -> bool:
    """Verifica si el caché es válido"""
    hash_file = Path(CACHE_DIR) / PDF_HASH_FILE
    index_path = Path(FAISS_INDEX_DIR)

    if not hash_file.exists() or not index_path.exists():
        return False

    if not (index_path / "index.faiss").exists():
        return False

    current_hash = calculate_pdfs_hash(pdf_files)
    try:
        stored_hash = hash_file.read_text().strip()
        return current_hash == stored_hash
    except:
        return False

def save_cache_hash(pdf_files: List[Path]):
    """Guarda el hash actual de los PDFs"""
    hash_file = Path(CACHE_DIR) / PDF_HASH_FILE
    current_hash = calculate_pdfs_hash(pdf_files)
    hash_file.write_text(current_hash)

def load_and_process_pdfs(pdf_files: List[Path]) -> List[Document]:
    """Carga y procesa los PDFs de normativas peruanas"""
    all_documents = []

    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=CHUNK_SIZE,
        chunk_overlap=CHUNK_OVERLAP,
        length_function=len,
        separators=["\n\n", "\n", "Artículo", "ARTÍCULO", " ", ""]
    )

    progress_bar = st.progress(0)
    status_text = st.empty()

    for idx, pdf_file in enumerate(pdf_files):
        law_type = identify_law_type(pdf_file.name)
        status_text.text(f"📜 Procesando: {law_type}")

        try:
            loader = PyPDFLoader(str(pdf_file))
            documents = loader.load()

            for doc in documents:
                doc.metadata['source_file'] = pdf_file.name
                doc.metadata['law_type'] = law_type

            splits = text_splitter.split_documents(documents)
            all_documents.extend(splits)

        except Exception as e:
            st.warning(f"Error procesando {pdf_file.name}: {str(e)}")

        progress_bar.progress((idx + 1) / len(pdf_files))

    progress_bar.empty()
    status_text.empty()

    return all_documents

@st.cache_resource
def get_or_create_vectorstore():
    """Obtiene o crea el vector store con caché inteligente"""

    # Verificar API key de forma más robusta
    try:
        if hasattr(st, 'secrets') and "OPENAI_API_KEY" in st.secrets:
            os.environ["OPENAI_API_KEY"] = st.secrets["OPENAI_API_KEY"]
    except:
        pass

    # Verificar que tenemos la API key
    if not os.getenv("OPENAI_API_KEY"):
        st.error("❌ No se encontró OPENAI_API_KEY en .env o Streamlit secrets")
        st.stop()

    pdf_files = get_pdf_files()
    if not pdf_files:
        return None

    embeddings = OpenAIEmbeddings(
        model="text-embedding-ada-002",  # Especifica el modelo
        openai_api_key=os.environ.get("OPENAI_API_KEY")
    )
    index_path = Path(FAISS_INDEX_DIR)

    if is_cache_valid(pdf_files):
        try:
            st.info("⚡ Cargando índice de normativas peruanas desde caché...")
            vectorstore = FAISS.load_local(
                str(index_path),
                embeddings,
                allow_dangerous_deserialization=True
            )
            st.success(f"✅ Base de datos normativa cargada ({len(pdf_files)} leyes peruanas)")
            return vectorstore
        except Exception as e:
            st.warning(f"Recreando índice: {e}")

    st.info("🔨 Construyendo índice de normativas peruanas...")

    documents = load_and_process_pdfs(pdf_files)

    if not documents:
        st.error("No se pudieron procesar las normativas")
        return None

    st.text(f"📊 Total de fragmentos normativos creados: {len(documents)}")

    with st.spinner("🧠 Generando embeddings de artículos y normativas..."):
        vectorstore = FAISS.from_documents(documents, embeddings)

    try:
        vectorstore.save_local(str(index_path))
        save_cache_hash(pdf_files)
        st.success("💾 Índice normativo guardado en caché")
    except Exception as e:
        st.warning(f"No se pudo guardar caché: {e}")

    return vectorstore

def analyze_compliance(vectorstore, query: str) -> str:
    """Realiza el análisis de cumplimiento normativo peruano"""
    try:
        llm = ChatOpenAI(
            model_name=MODEL_NAME,
            temperature=TEMPERATURE,
            max_tokens=MAX_TOKENS
        )

        prompt = PromptTemplate(
            template=PROMPT_TEMPLATE,
            input_variables=["context", "question"]
        )

        qa_chain = RetrievalQA.from_chain_type(
            llm=llm,
            chain_type="stuff",
            retriever=vectorstore.as_retriever(
                search_kwargs={"k": 8}  # Más chunks para análisis completo
            ),
            chain_type_kwargs={"prompt": prompt},
            return_source_documents=True
        )

        with st.spinner("🤖 Analizando cumplimiento con normativa peruana..."):
            result = qa_chain({"query": query})

        return result["result"]

    except Exception as e:
        return f"❌ Error en el análisis: {str(e)}"

# =====================================================
# INTERFAZ PRINCIPAL DE STREAMLIT
# =====================================================

def main():
    st.set_page_config(
        page_title="IndraLex Perú",
        page_icon="🇵🇪",
        layout="wide"
    )

    # CSS personalizado con colores de Indra
    st.markdown("""
    <style>
    .main {
        padding-top: 2rem;
    }
    .stButton>button {
        width: 100%;
        background-color: #0066CC;
        color: white;
    }
    .stButton>button:hover {
        background-color: #0052A3;
    }
    h1 {
        color: #0066CC;
    }
    </style>
    """, unsafe_allow_html=True)

    # Header con logo de Perú
    st.title("🇵🇪 IndraLex - Asistente de Cumplimiento Normativo Peruano")
    st.markdown("""
    *Herramienta de IA para análisis de cumplimiento normativo en proyectos tecnológicos en Perú.
    Especializada en normativas peruanas de protección de datos, gobierno digital y sector financiero.*
    """)

    ensure_directories()

    # Sidebar con información
    with st.sidebar:
        st.header("📋 Estado del Sistema")

        api_key_status = "✅ Configurada" if os.getenv("OPENAI_API_KEY") else "❌ No configurada"
        st.write(f"**API Key:** {api_key_status}")

        pdf_files = get_pdf_files()
        st.write(f"**Normativas cargadas:** {len(pdf_files)}")
        if pdf_files:
            with st.expander("📚 Ver normativas"):
                for pdf in pdf_files:
                    law_type = identify_law_type(pdf.name)
                    st.write(f"• {law_type}")

        cache_status = "✅ Válido" if is_cache_valid(pdf_files) else "🔄 Requiere actualización"
        st.write(f"**Estado del caché:** {cache_status}")

        st.markdown("---")
        st.info(f"**Modelo:** {MODEL_NAME}")
        st.info("**Chunks por búsqueda:** 8")

        st.markdown("---")
        with st.expander("📌 Acerca de IndraLex"):
            st.markdown("""
            **Desarrollado para:** Indra Perú / Minsait
            
            **Sectores objetivos:**
            - 🏛️ Gobierno Digital (PCM, SEGDI)
            - 🏦 Banca y Finanzas (SBS)
            - 📱 Telecomunicaciones (OSIPTEL)
            - 🆔 Identidad Digital (RENIEC)
            - 💰 Administración Tributaria (SUNAT)
            
            **Normativas incluidas:**
            - Ley 29733 (Datos Personales)
            - DL 1412 (Gobierno Digital)
            - Circulares SBS
            - Ley 30096 (Delitos Informáticos)
            - Ley 27269 (Firmas Digitales)
            
            **Cumple con:**
            - Lineamientos SEGDI
            - Estándares PCM
            - Normativa sectorial
            """)

    # Área principal
    st.markdown("---")

    # Tabs para diferentes tipos de análisis
    tab1, tab2, tab3 = st.tabs(["📝 Análisis de Proyecto", "🏢 Casos Indra", "📖 Guía Rápida"])

    with tab1:
        proyecto_descripcion = st.text_area(
            "Describe el proyecto tecnológico a implementar en Perú:",
            height=150,
            placeholder="Ejemplo: Sistema de identificación biométrica para entidad bancaria peruana que almacenará datos personales, realizará verificación de identidad en tiempo real y se integrará con RENIEC..."
        )

        col1, col2, col3 = st.columns([1,2,1])
        with col2:
            analyze_button = st.button("🔍 Analizar Cumplimiento Normativo", type="primary")

        if analyze_button:
            if not proyecto_descripcion:
                st.error("Por favor, describe el proyecto antes de analizar.")
            else:
                with st.spinner("Preparando análisis normativo..."):
                    vectorstore = get_or_create_vectorstore()

                if vectorstore:
                    response = analyze_compliance(vectorstore, proyecto_descripcion)

                    st.markdown("---")
                    st.markdown("## 📊 Resultado del Análisis de Cumplimiento")

                    with st.container():
                        st.markdown(response)

                    col1, col2 = st.columns(2)
                    with col1:
                        st.download_button(
                            label="📥 Descargar Análisis",
                            data=f"INDRALEX - ANÁLISIS DE CUMPLIMIENTO NORMATIVO PERUANO\n\nFecha: {datetime.now().strftime('%Y-%m-%d %H:%M')}\n\nProyecto:\n{proyecto_descripcion}\n\n{response}",
                            file_name=f"analisis_indralex_{datetime.now().strftime('%Y%m%d_%H%M')}.txt",
                            mime="text/plain"
                        )
                    with col2:
                        st.button("📧 Enviar a equipo legal", disabled=True, help="Funcionalidad disponible en versión completa")
                else:
                    st.error("No se pudo inicializar el sistema.")

    with tab2:
        st.markdown("### 💼 Casos de Uso Típicos - Proyectos Indra Perú")

        col1, col2 = st.columns(2)

        with col1:
            st.markdown("""
            **🏛️ Transformación Digital - Sector Público**
            ```
            Plataforma de interoperabilidad para entidades 
            del Estado peruano que procesará datos ciudadanos,
            permitirá firma digital de documentos y cumplirá 
            con lineamientos de PCM y SEGDI.
            ```
            
            **🆔 Modernización RENIEC**
            ```
            Sistema de identificación digital con datos 
            biométricos, DNI electrónico y validación de 
            identidad para servicios públicos en línea.
            ```
            """)

        with col2:
            st.markdown("""
            **🏦 Banca Digital - SBS**
            ```
            Sistema de banca móvil para entidad regulada 
            por SBS con autenticación biométrica, 
            procesamiento de transacciones y cumplimiento 
            de circulares de ciberseguridad.
            ```
            
            **🚇 Smart Cities Lima**
            ```
            Plataforma IoT para Lima Metropolitana con 
            recopilación de datos de sensores, videovigilancia
            y procesamiento en tiempo real para gestión urbana.
            ```
            """)

    with tab3:
        st.markdown("""
        ### 📚 Guía de Uso Rápido
        
        **1️⃣ Preparación:**
        - Asegúrate de tener las normativas peruanas en la carpeta `legislacion/`
        - Verifica que la API key esté configurada
        
        **2️⃣ Descripción del Proyecto:**
        - Sé específico sobre el sector (público/privado)
        - Menciona el tipo de datos que manejará
        - Indica si hay integración con entidades del Estado
        - Especifica el alcance geográfico en Perú
        
        **3️⃣ Interpretación de Resultados:**
        - 🏛️ **Marco Legal**: Leyes aplicables al proyecto
        - 📑 **Análisis Detallado**: Artículos específicos y obligaciones
        - 🔧 **Requisitos Técnicos**: Implementaciones necesarias
        - ✅ **Plan de Cumplimiento**: Pasos a seguir
        - ⚖️ **Entidades**: Organismos reguladores involucrados
        
        **4️⃣ Siguientes Pasos:**
        - Descargar el análisis para documentación
        - Revisar con el equipo legal de Indra
        - Validar con las entidades reguladoras correspondientes
        """)

    # Footer
    st.markdown("---")
    st.caption("IndraLex v2.0 - Especializado en Normativa Peruana | Desarrollado para Indra/Minsait Perú")

if __name__ == "__main__":
    main()