import os
import sqlite3
import logging
from flask import Flask, render_template, jsonify, request

# Configuración
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
TEMPLATE_DIR = os.path.join(BASE_DIR, 'templates')
DB_PATH = os.path.join(BASE_DIR, 'wms_database.db')
LOG_FILE = os.path.join(BASE_DIR, 'wms_app.log')

# Logging
logging.basicConfig(
    filename=LOG_FILE,
    level=logging.INFO,
    format='%(asctime)s %(levelname)s: %(message)s'
)

# Importar cliente
try:
    from defontana_client import DefontanaClient
    defontana_client = DefontanaClient()
except Exception as e:
    logging.error(f"Error al importar DefontanaClient: {e}")
    defontana_client = None

# Flask App
application = Flask(__name__, template_folder=TEMPLATE_DIR)

def get_db():
    conn = sqlite3.connect(DB_PATH)
    conn.row_factory = sqlite3.Row
    return conn

# ==================== RUTAS PRINCIPALES ====================

@application.route('/')
def dashboard():
    return render_template('dashboard.html')

@application.route('/productos')
def productos():
    return render_template('productos.html')

@application.route('/picking')
def picking():
    return render_template('picking.html')

# ==================== API STATS ====================

@application.route('/api/stats')
def api_stats():
    try:
        db = get_db()
        total = db.execute("SELECT COUNT(*) as c FROM productos").fetchone()['c']
        con_stock = db.execute("SELECT COUNT(*) as c FROM productos WHERE stock > 0").fetchone()['c']
        con_fisico = db.execute("SELECT COUNT(*) as c FROM productos WHERE stock_fisico > 0").fetchone()['c']
        
        return jsonify({
            "total_products": total,
            "products_with_stock_erp": con_stock,
            "products_with_stock_fisico": con_fisico
        })
    except Exception as e:
        logging.error(f"Error en /api/stats: {e}")
        return jsonify({"total_products": 0, "products_with_stock_erp": 0, "products_with_stock_fisico": 0})

# ==================== API SYNC ====================

@application.route('/api/sync', methods=['POST', 'GET'])
def api_sync():
    if not defontana_client:
        return jsonify({"success": False, "error": "Cliente Defontana no disponible"}), 500

    try:
        logging.info("Iniciando sync inteligente...")
        
        # 1. Descargar productos
        productos = defontana_client.get_products_with_stock()
        
        if not productos:
            return jsonify({"success": False, "message": "No se obtuvieron productos"}), 400

        # 2. Conectar DB
        db = get_db()
        
        # 3. Crear tabla si no existe
        db.execute('''
            CREATE TABLE IF NOT EXISTS productos (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                id_defontana TEXT,
                codigo TEXT,
                nombre TEXT,
                stock REAL,
                precio REAL,
                stock_fisico REAL DEFAULT 0,
                estado TEXT DEFAULT 'activo',
                imagen_url TEXT,
                ean TEXT,
                dun TEXT
            )
        ''')

        # 4. Backup de datos locales
        backup_local = {}
        try:
            for row in db.execute("SELECT codigo, stock_fisico, imagen_url, ean, dun FROM productos"):
                if row['codigo']:
                    backup_local[row['codigo']] = {
                        'fisico': row['stock_fisico'] or 0,
                        'img': row['imagen_url'] or '',
                        'ean': row['ean'] or '',
                        'dun': row['dun'] or ''
                    }
        except:
            pass

        # 5. Borrado masivo
        db.execute("DELETE FROM productos")

        # 6. Insertar todo de nuevo
        for p in productos:
            local = backup_local.get(p['codigo'], {})
            
            db.execute('''
                INSERT INTO productos (id_defontana, codigo, nombre, stock, precio, stock_fisico, imagen_url, ean, dun)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
            ''', (
                p['id'],
                p['codigo'],
                p['nombre'],
                p['stock'],
                p['precio'],
                local.get('fisico', 0),
                local.get('img', ''),
                local.get('ean', ''),
                local.get('dun', '')
            ))

        db.commit()
        
        logging.info(f"Sync completado: {len(productos)} productos")
        return jsonify({"success": True, "count": len(productos)})

    except Exception as e:
        logging.error(f"Error CRÍTICO en sync: {e}")
        return jsonify({"success": False, "error": str(e)}), 500

# ==================== API PRODUCTOS ====================

@application.route('/api/products/search')
def api_search():
    q = request.args.get('q', '').lower()
    try:
        db = get_db()
        if q:
            rows = db.execute("""
                SELECT * FROM productos 
                WHERE (nombre LIKE ? OR codigo LIKE ?) AND estado = 'activo'
                ORDER BY nombre LIMIT 500
            """, (f'%{q}%', f'%{q}%')).fetchall()
        else:
            rows = db.execute("SELECT * FROM productos WHERE estado = 'activo' ORDER BY nombre LIMIT 500").fetchall()
        
        return jsonify([dict(r) for r in rows])
    except Exception as e:
        logging.error(f"Error en search: {e}")
        return jsonify([])

# ==================== API PICKING ====================

@application.route('/api/picking/ventas', methods=['POST'])
def api_ventas():
    if not defontana_client:
        return jsonify({"success": False, "error": "Cliente no disponible"}), 500
    
    try:
        data = request.json
        # 1. Traemos las ventas de Defontana (vienen sin nombres de producto)
        result = defontana_client.get_ventas_por_fecha(
            data.get('fecha_inicio'),
            data.get('fecha_fin')
        )
        
        if result['success']:
            # 2. Conectamos a la DB local para buscar los nombres reales
            db = get_db()
            # Creamos un diccionario {codigo: nombre} para búsqueda rápida
            productos_db = {
                row['codigo'].strip().upper(): row['nombre'] 
                for row in db.execute("SELECT codigo, nombre FROM productos").fetchall()
            }
            
            # 3. Enriquecemos la lista de ventas
            for venta in result['ventas']:
                for item in venta['items']:
                    codigo_limpio = item['codigo'].strip().upper()
                    # Si el producto existe en nuestra DB, usamos ese nombre. Si no, dejamos el original.
                    if codigo_limpio in productos_db:
                        item['nombre'] = productos_db[codigo_limpio]
                    else:
                        item['nombre'] = "Producto no catalogado"

        return jsonify(result)
    except Exception as e:
        return jsonify({"success": False, "error": str(e)}), 500


# ==================== LOG VIEWER ====================

@application.route('/log')
def ver_log():
    try:
        with open(LOG_FILE, 'r') as f:
            lines = f.readlines()[-100:]
        return f"<pre>{''.join(lines)}</pre>"
    except:
        return "No hay logs disponibles"
# ==================== RESPALDO AUTOMÁTICO ====================

@application.route('/crear_respaldo')
def crear_respaldo():
    try:
        import subprocess
        import zipfile
        from datetime import datetime
        
        # Crear carpeta de respaldos
        backup_dir = os.path.join(BASE_DIR, 'respaldos')
        os.makedirs(backup_dir, exist_ok=True)
        
        # Nombre del respaldo
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        backup_name = f"WMS_RESPALDO_{timestamp}.zip"
        backup_path = os.path.join(backup_dir, backup_name)
        
        # Archivos a respaldar
        archivos = [
            'main.py',
            'defontana_client.py',
            'passenger_wsgi.py',
            'wms_database.db',
            'wms_app.log'
        ]
        
        # Crear ZIP
        with zipfile.ZipFile(backup_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
            # Archivos individuales
            for item in archivos:
                item_path = os.path.join(BASE_DIR, item)
                if os.path.exists(item_path):
                    zipf.write(item_path, arcname=item)
            
            # Carpeta templates completa
            templates_dir = os.path.join(BASE_DIR, 'templates')
            if os.path.exists(templates_dir):
                for root, dirs, files in os.walk(templates_dir):
                    for file in files:
                        file_path = os.path.join(root, file)
                        arcname = os.path.relpath(file_path, BASE_DIR)
                        zipf.write(file_path, arcname=arcname)
        
        size_kb = os.path.getsize(backup_path) / 1024
        
        return f"""
        <html>
        <head>
            <title>Respaldo Creado</title>
            <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
        </head>
        <body class="bg-light">
            <div class="container mt-5">
                <div class="card shadow">
                    <div class="card-body text-center">
                        <i class="fas fa-check-circle text-success" style="font-size: 4rem;"></i>
                        <h2 class="mt-3">✅ Respaldo Creado Exitosamente</h2>
                        <p class="text-muted">Archivo: <code>{backup_name}</code></p>
                        <p>Tamaño: <strong>{size_kb:.2f} KB</strong></p>
                        <hr>
                        <p>📁 Ubicación: <code>/wms/respaldos/</code></p>
                        <a href="{{ url_for('dashboard') }}" class="btn btn-primary mt-3">Volver al Dashboard</a>
                        <a href="/wms/respaldos/{backup_name}" class="btn btn-success mt-3" download>⬇️ Descargar Respaldo</a>
                    </div>
                </div>
            </div>
        </body>
        </html>
        """
        
    except Exception as e:
        return f"<h2>Error al crear respaldo</h2><pre>{str(e)}</pre>"
@application.route('/debug_ventas')
def debug_ventas():
    try:
        import requests
        # Usamos tu cliente ya configurado
        client = DefontanaClient()
        if not client.get_token():
            return "Error Login"
            
        url = f"{client.api_link}Sale/GetSaleByDate"
        headers = {"Authorization": f"Bearer {client.token}"}
        
        # Pedimos solo 1 página de hoy
        import datetime
        hoy = datetime.datetime.now().strftime("%Y-%m-%d")
        # Si hoy no hay ventas, probamos ayer o una fecha fija que sepas que tiene datos
        # Usa una fecha donde sepas que hay ventas para que salga data
        fecha_test = "2026-01-20" 
        
        params = {
            "initialDate": fecha_test, 
            "endingDate": fecha_test, 
            "itemsPerPage": 5, 
            "pageNumber": 1
        }
        
        resp = requests.get(url, headers=headers, params=params)
        data = resp.json()
        
        # Mostramos el JSON crudo en el navegador para ver los nombres reales
        return jsonify(data)
        
    except Exception as e:
        return str(e)

if __name__ == "__main__":
    application.run(debug=False)