main.py

from telethon import TelegramClient, events
import time
import threading
import os
import asyncio
import re
import requests

#logging
import csv
import datetime


# Variabili d'ambiente
api_id = int(os.getenv('API_ID'))
api_hash = os.getenv('API_HASH')
source_chat = -1002141199775  # ID gruppo privato
###source_chat = -1002355915425  # ID gruppo debug purpose
destination_chat = 690164647  # ID Bot
WEBHOOK_URL = os.getenv('WEBHOOK_URL')
WEBHOOK_SECRET = os.getenv('WEBHOOK_SECRET')

# IG Markets credentials
USERNAME = os.getenv('IG_USERNAME')
PASSWORD = os.getenv('IG_PASSWORD')
API_KEY = os.getenv('IG_API_KEY')
BASE_URL = 'https://demo-api.ig.com/gateway/deal'

# Crea client Telethon
client = TelegramClient('session_copytrading', api_id, api_hash)

def login_ig():
    headers = {
        "Content-Type": "application/json",
        "Accept": "application/json",
        "X-IG-API-KEY": API_KEY,
        "Version": "2"
    }
    payload = {
        "identifier": USERNAME,
        "password": PASSWORD
    }
    res = requests.post(f"{BASE_URL}/session", headers=headers, json=payload)
    if res.status_code != 200:
        print("Errore autenticazione IG:", res.text)
        return None, None, None
    return res.headers["CST"], res.headers["X-SECURITY-TOKEN"], res.json()["currentAccountId"]

def parse_signal(msg):
    lines = msg.strip().splitlines()
    data = {}
    for line in lines:
        if match := re.match(r'(Buy|Sell):\s*(\d+(\.\d+)?)', line, re.IGNORECASE):
            data['direction'] = match.group(1).capitalize()
        elif line.startswith('SL:'):
            data['sl'] = float(line.split(':')[1].strip())
        elif line.startswith('TP2:'):
            data['tp2'] = float(line.split(':')[1].strip())
        elif line.startswith('TP4:'):
            data['tp4'] = float(line.split(':')[1].strip())
    if not all(k in data for k in ['direction', 'sl', 'tp2', 'tp4']):
        raise Warning("Messaggio non è un ordine o malformattato")
    return data

def confirm_order(deal_ref, cst, x_sec):
    headers = {
        "X-IG-API-KEY": API_KEY,
        "CST": cst,
        "X-SECURITY-TOKEN": x_sec,
        "Accept": "application/json",
        "Version": "1"
    }
    res = requests.get(f"{BASE_URL}/confirms/{deal_ref}", headers=headers)
    if res.status_code != 200:
        return None, None, None
    data = res.json()
    return data.get("dealStatus"), data.get("reason"), data.get("level"), data.get("stopLevel")

def place_order(tp, direction, sl, cst, x_sec):
    headers = {
        "X-IG-API-KEY": API_KEY,
        "CST": cst,
        "X-SECURITY-TOKEN": x_sec,
        "Content-Type": "application/json",
        "Version": "2"
    }
    payload = {
        "epic": "CS.D.CFDGOLD.CFDGC.IP",
        "expiry": "-",
        "direction": direction.upper(),
        "size": 0.2,
        "orderType": "MARKET",
        "guaranteedStop": False,
        "forceOpen": True,
        "limitLevel": tp,
        "stopLevel": sl,
        "currencyCode": "USD",
        "timeInForce": "FILL_OR_KILL"
    }
    res = requests.post(f"{BASE_URL}/positions/otc", headers=headers, json=payload)
    if res.status_code != 200:
        return None, None, None, None
    
    deal_ref = res.json().get("dealReference")
    status, reason, level, stop_level = confirm_order(deal_ref, cst, x_sec)

    return status, reason, level, stop_level, deal_ref

# Handle message signal and call trade
async def handle_signal_and_trade(msg):
    try:
        signal = parse_signal(msg)
        cst, x_sec, acc_id = login_ig()
        if not cst:
            await client.send_message(destination_chat, "❌ Login fallito su IG.")
            return

        # Ordine 1 con TP2
        status1, reason1, price1, sl1, deal1 = place_order(signal['tp2'], signal['direction'], signal['sl'], cst, x_sec)

        if status1 == "ACCEPTED":
            log_order_to_csv({
                'direction': signal['direction'],
                'tp': signal['tp2'],
                'sl': sl1,
                'level': price1,
                'dealReference': deal1,
                'openLevel': price1
            })

        # Ordine 2 con TP4
        status2, reason2, price2, sl2, deal2 = place_order(signal['tp4'], signal['direction'], signal['sl'], cst, x_sec)

        if status2 == "ACCEPTED":
            log_order_to_csv({
                'direction': signal['direction'],
                'tp': signal['tp4'],
                'sl': sl2,
                'level': price2,
                'dealReference': deal2,
                'openLevel': price2
            })

        if status1 == "ACCEPTED" and status2 == "ACCEPTED":
            text = (
                f"✅ **2 ordini su XAUUSD aperti**:\n\n"
                f"📌 Direzione: **{signal['direction']}**\n"
                f"🔸 **Ordine 1**: Entry = `{price1}` | TP = `{signal['tp2']}` | SL = `{sl1}` | DealRef = `{deal1}`\n"
                f"🔸 **Ordine 2**: Entry = `{price2}` | TP = `{signal['tp4']}` | SL = `{sl2}` | DealRef = `{deal2}`"
            )
        else:
            text = (
                f"❌ Problemi nell'aprire gli ordini:\n"
                f"🔹 **Ordine 1**: {status1} — **{reason1}**\n"
                f"🔹 **Ordine 2**: {status2} — **{reason2}**"
            )
            print(text)

        await client.send_message(destination_chat, text, parse_mode='markdown')

    except Exception as e:
        print(f"[⚠️] Problema nel gestire segnale: {e}")
        # await client.send_message(destination_chat, f"⚠️ Errore nel gestire segnale: `{e}`", parse_mode="markdown")

# Log into csv function
def log_order_to_csv(data):
    timestamp = datetime.datetime.now(datetime.timezone.utc).isoformat()
    filename = 'order_log.csv'
    row = {
        'timestamp': timestamp,
        'direction': data.get('direction'),
        'tp': data.get('tp'),
        'sl': data.get('sl'),
        'level': data.get('level'),
        'dealReference': data.get('dealReference'),
        'openLevel': data.get('openLevel')
    }

    file_exists = os.path.isfile(filename)
    with open(filename, 'a', newline='') as csvfile:
        fieldnames = row.keys()
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

        if not file_exists:
            writer.writeheader()
        writer.writerow(row)
    print(f"[📁] Ordine salvato su {filename}")


# Handler dei messaggi in arrivo sul Gruppo privato
@client.on(events.NewMessage(chats=source_chat))
async def handler(event):
    print(f"[📩] Nuovo messaggio ricevuto: {event.raw_text}")
    await forward_last_message(event)
    await handle_signal_and_trade(event.raw_text)

async def forward_last_message(event):
    try:
        await event.forward_to(destination_chat)
        print("[➡️] Messaggio inoltrato al bot")
    except Exception as e:
        print(f"[❌] Errore inoltro: {e}")

def heartbeat():
    while True:
        print("[🟢] App attiva e in ascolto...")
        time.sleep(3600*4)  # bit ogni 4 ore

async def main():
    print("[🚀] Avvio listener Telethon...")
    await client.start()
    await client.run_until_disconnected()

if __name__ == "__main__":
    # ✅ Avvio thread heartbeat
    threading.Thread(target=heartbeat, daemon=True).start()

    # ✅ Avvio main
    asyncio.run(main())