#!/usr/bin/env python3
"""
DIÁRIO FÍSICO - TELEGRAM BOT
Bot para logging rápido de hábitos, push-ups, gratidões e insights

Comandos disponíveis:
- /start - Iniciar bot
- /help - Mostrar ajuda
- /status - Ver progresso do dia
- /pushups <número> - Adicionar push-ups
- /gratitude <texto> - Adicionar gratidão
- /insight <texto> - Salvar insight
- /habit <nome> - Marcar hábito como completo
- /export - Exportar dados do dia
"""

import os
import json
import logging
from datetime import datetime
from flask import Flask, request, jsonify
from flask_cors import CORS

# Setup logging
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)
logger = logging.getLogger(__name__)

# Flask app
app = Flask(__name__)
CORS(app)

# Config
BOT_TOKEN = os.environ.get('TELEGRAM_BOT_TOKEN', '')
DATA_FILE = '/Users/neog/telegram-bot-data.json'

# ===== DATA MANAGEMENT =====

def load_data():
    """Carrega dados do arquivo JSON"""
    if os.path.exists(DATA_FILE):
        with open(DATA_FILE, 'r', encoding='utf-8') as f:
            return json.load(f)
    return {}

def save_data(data):
    """Salva dados no arquivo JSON"""
    with open(DATA_FILE, 'w', encoding='utf-8') as f:
        json.dump(data, f, indent=2, ensure_ascii=False)

def get_today():
    """Retorna data de hoje no formato YYYY-MM-DD"""
    return datetime.now().strftime('%Y-%m-%d')

def init_today_data(data):
    """Inicializa dados do dia se não existirem"""
    today = get_today()
    if today not in data:
        data[today] = {
            'pushups': 0,
            'gratitudes': [],
            'insights': [],
            'habits': {
                'meditation': False,
                'water': False,
                'walk': False,
                'writing': False
            },
            'messages': []
        }
    return data

# ===== TELEGRAM API HELPERS =====

def send_telegram_message(chat_id, text):
    """Envia mensagem via Telegram API"""
    import requests

    if not BOT_TOKEN:
        logger.error('BOT_TOKEN não configurado')
        return False

    url = f'https://api.telegram.org/bot{BOT_TOKEN}/sendMessage'
    payload = {
        'chat_id': chat_id,
        'text': text,
        'parse_mode': 'Markdown'
    }

    try:
        response = requests.post(url, json=payload)
        return response.json()
    except Exception as e:
        logger.error(f'Erro ao enviar mensagem: {e}')
        return False

# ===== BOT COMMANDS =====

def cmd_start(chat_id):
    """Comando /start"""
    message = """
🌿 *Bem-vindo ao Diário Físico Bot!*

Use os seguintes comandos para registrar seu progresso:

📊 *Status e Dados:*
/status - Ver progresso de hoje
/export - Exportar dados do dia

💪 *Hábitos e Exercícios:*
/pushups <número> - Ex: `/pushups 50`
/habit <nome> - Ex: `/habit meditation`
  Hábitos: meditation, water, walk, writing

🙏 *Gratidão e Insights:*
/gratitude <texto> - Ex: `/gratitude Saúde da família`
/insight <texto> - Ex: `/insight Preciso focar mais`

❓ *Ajuda:*
/help - Mostrar esta mensagem

---
_Desenvolvido com ❤️ para autoconsciência_
"""
    send_telegram_message(chat_id, message)

def cmd_help(chat_id):
    """Comando /help"""
    cmd_start(chat_id)

def cmd_status(chat_id):
    """Comando /status"""
    data = load_data()
    data = init_today_data(data)
    today = get_today()
    today_data = data[today]

    # Calcular estatísticas
    pushups = today_data['pushups']
    pushups_percent = min(int((pushups / 200) * 100), 100)

    habits_completed = sum(1 for v in today_data['habits'].values() if v)
    habits_total = len(today_data['habits'])
    habits_percent = int((habits_completed / habits_total) * 100)

    gratitudes_count = len(today_data['gratitudes'])
    insights_count = len(today_data['insights'])

    # Montar mensagem
    message = f"""
📊 *Seu Progresso de Hoje* ({today})

💪 *Push-ups:* {pushups}/200 ({pushups_percent}%)
{'🟢' * (pushups_percent // 20)}{'⚪' * (5 - pushups_percent // 20)}

✅ *Hábitos:* {habits_completed}/{habits_total} ({habits_percent}%)
{'✓' if today_data['habits']['meditation'] else '○'} Meditação
{'✓' if today_data['habits']['water'] else '○'} Água (8 copos)
{'✓' if today_data['habits']['walk'] else '○'} Caminhar
{'✓' if today_data['habits']['writing'] else '○'} 2h de escrita

🙏 *Gratidões:* {gratitudes_count}/3
💡 *Insights:* {insights_count}

---
_Continue assim! 🔥_
"""
    send_telegram_message(chat_id, message)

def cmd_pushups(chat_id, amount):
    """Comando /pushups <número>"""
    try:
        amount = int(amount)
        if amount <= 0 or amount > 500:
            send_telegram_message(chat_id, '❌ Número inválido. Use entre 1 e 500.')
            return

        data = load_data()
        data = init_today_data(data)
        today = get_today()

        data[today]['pushups'] += amount
        total = data[today]['pushups']

        save_data(data)

        message = f"""
✅ *{amount} push-ups adicionados!*

Total hoje: *{total}/200* ({min(int((total/200)*100), 100)}%)

{'🎉 Meta alcançada!' if total >= 200 else f'Faltam {200 - total} para a meta!'}
"""
        send_telegram_message(chat_id, message)

    except ValueError:
        send_telegram_message(chat_id, '❌ Use: /pushups <número>\nEx: /pushups 50')

def cmd_gratitude(chat_id, text):
    """Comando /gratitude <texto>"""
    if not text:
        send_telegram_message(chat_id, '❌ Use: /gratitude <texto>\nEx: /gratitude Saúde da família')
        return

    data = load_data()
    data = init_today_data(data)
    today = get_today()

    data[today]['gratitudes'].append({
        'text': text,
        'timestamp': datetime.now().isoformat()
    })

    count = len(data[today]['gratitudes'])
    save_data(data)

    message = f"""
🙏 *Gratidão registrada!*

_{text}_

Total hoje: {count}/3
"""
    send_telegram_message(chat_id, message)

def cmd_insight(chat_id, text):
    """Comando /insight <texto>"""
    if not text:
        send_telegram_message(chat_id, '❌ Use: /insight <texto>\nEx: /insight Preciso focar mais')
        return

    data = load_data()
    data = init_today_data(data)
    today = get_today()

    data[today]['insights'].append({
        'text': text,
        'timestamp': datetime.now().isoformat()
    })

    count = len(data[today]['insights'])
    save_data(data)

    message = f"""
💡 *Insight salvo!*

_{text}_

Total hoje: {count}
"""
    send_telegram_message(chat_id, message)

def cmd_habit(chat_id, habit_name):
    """Comando /habit <nome>"""
    valid_habits = ['meditation', 'water', 'walk', 'writing']
    habit_names = {
        'meditation': 'Meditação',
        'water': 'Água (8 copos)',
        'walk': 'Caminhar',
        'writing': '2h de escrita'
    }

    if habit_name not in valid_habits:
        send_telegram_message(
            chat_id,
            f"❌ Hábito inválido.\nUse: {', '.join(valid_habits)}\nEx: /habit meditation"
        )
        return

    data = load_data()
    data = init_today_data(data)
    today = get_today()

    data[today]['habits'][habit_name] = True
    save_data(data)

    completed = sum(1 for v in data[today]['habits'].values() if v)
    total = len(data[today]['habits'])

    message = f"""
✅ *Hábito completado!*

{habit_names[habit_name]}

Progresso: {completed}/{total} hábitos
{'🎉 Todos os hábitos completados hoje!' if completed == total else ''}
"""
    send_telegram_message(chat_id, message)

def cmd_export(chat_id):
    """Comando /export"""
    data = load_data()
    data = init_today_data(data)
    today = get_today()
    today_data = data[today]

    # Formatar dados para export
    export_text = f"""
📅 *Exportação de Dados - {today}*

---

💪 *Push-ups:* {today_data['pushups']}/200

---

✅ *Hábitos Completados:*
{'✓' if today_data['habits']['meditation'] else '○'} Meditação
{'✓' if today_data['habits']['water'] else '○'} Água
{'✓' if today_data['habits']['walk'] else '○'} Caminhar
{'✓' if today_data['habits']['writing'] else '○'} Escrita

---

🙏 *Gratidões:*
"""

    for i, g in enumerate(today_data['gratitudes'], 1):
        export_text += f"\n{i}. {g['text']}"

    if not today_data['gratitudes']:
        export_text += "\n_Nenhuma gratidão registrada_"

    export_text += "\n\n---\n\n💡 *Insights:*\n"

    for i, ins in enumerate(today_data['insights'], 1):
        export_text += f"\n{i}. {ins['text']}"

    if not today_data['insights']:
        export_text += "\n_Nenhum insight registrado_"

    export_text += "\n\n---\n_Gerado pelo Diário Físico Bot_"

    send_telegram_message(chat_id, export_text)

# ===== WEBHOOK HANDLER =====

@app.route('/webhook', methods=['POST'])
def webhook():
    """Recebe updates do Telegram"""
    try:
        update = request.json
        logger.info(f'Received update: {update}')

        if 'message' not in update:
            return jsonify({'ok': True})

        message = update['message']
        chat_id = message['chat']['id']
        text = message.get('text', '')

        # Log da mensagem
        data = load_data()
        data = init_today_data(data)
        today = get_today()
        data[today]['messages'].append({
            'text': text,
            'timestamp': datetime.now().isoformat(),
            'user': message['from'].get('username', 'unknown')
        })
        save_data(data)

        # Processar comandos
        if text.startswith('/'):
            parts = text.split(maxsplit=1)
            command = parts[0].lower()
            args = parts[1] if len(parts) > 1 else ''

            if command == '/start':
                cmd_start(chat_id)
            elif command == '/help':
                cmd_help(chat_id)
            elif command == '/status':
                cmd_status(chat_id)
            elif command == '/pushups':
                cmd_pushups(chat_id, args)
            elif command == '/gratitude':
                cmd_gratitude(chat_id, args)
            elif command == '/insight':
                cmd_insight(chat_id, args)
            elif command == '/habit':
                cmd_habit(chat_id, args)
            elif command == '/export':
                cmd_export(chat_id)
            else:
                send_telegram_message(chat_id, '❌ Comando desconhecido. Use /help para ver comandos disponíveis.')

        return jsonify({'ok': True})

    except Exception as e:
        logger.error(f'Error in webhook: {e}')
        return jsonify({'ok': False, 'error': str(e)}), 500

# ===== API ENDPOINTS =====

@app.route('/api/data', methods=['GET'])
def get_data():
    """Retorna todos os dados"""
    data = load_data()
    return jsonify(data)

@app.route('/api/data/<date>', methods=['GET'])
def get_data_by_date(date):
    """Retorna dados de uma data específica"""
    data = load_data()
    return jsonify(data.get(date, {}))

@app.route('/api/sync', methods=['POST'])
def sync_data():
    """Sincroniza dados do frontend com backend"""
    try:
        incoming_data = request.json
        data = load_data()

        # Merge data
        for date, date_data in incoming_data.items():
            if date not in data:
                data[date] = date_data
            else:
                # Merge intelligently
                if 'pushups' in date_data:
                    data[date]['pushups'] = max(data[date].get('pushups', 0), date_data['pushups'])
                if 'habits' in date_data:
                    data[date]['habits'] = {**data[date].get('habits', {}), **date_data['habits']}
                if 'gratitudes' in date_data:
                    existing = [g['text'] for g in data[date].get('gratitudes', [])]
                    for g in date_data['gratitudes']:
                        if g['text'] not in existing:
                            data[date].setdefault('gratitudes', []).append(g)
                if 'insights' in date_data:
                    existing = [i['text'] for i in data[date].get('insights', [])]
                    for i in date_data['insights']:
                        if i['text'] not in existing:
                            data[date].setdefault('insights', []).append(i)

        save_data(data)
        return jsonify({'ok': True, 'message': 'Dados sincronizados'})

    except Exception as e:
        logger.error(f'Error in sync: {e}')
        return jsonify({'ok': False, 'error': str(e)}), 500

@app.route('/api/health', methods=['GET'])
def health():
    """Health check"""
    return jsonify({
        'status': 'ok',
        'bot_configured': bool(BOT_TOKEN),
        'timestamp': datetime.now().isoformat()
    })

# ===== MAIN =====

if __name__ == '__main__':
    logger.info('Starting Telegram Bot server...')
    logger.info(f'Bot token configured: {bool(BOT_TOKEN)}')
    logger.info(f'Data file: {DATA_FILE}')

    # Initialize data file
    if not os.path.exists(DATA_FILE):
        save_data({})
        logger.info('Created empty data file')

    # Run server
    port = int(os.environ.get('PORT', 5000))
    app.run(host='0.0.0.0', port=port, debug=True)