import tweepy
import time
import requests
import sqlite3
from telegram.ext import Updater, CommandHandler, JobQueue, CallbackContext
from telegram import Bot, Update
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score
from textblob import TextBlob

# X API credentials (replace with your actual credentials)
CONSUMER_KEY = 'your_consumer_key'
CONSUMER_SECRET = 'your_consumer_secret'
ACCESS_TOKEN = 'your_access_token'
ACCESS_TOKEN_SECRET = 'your_access_token_secret'

# GMGN API credentials
GMGN_API_KEY = 'your_gmgn_api_key'
GMGN_API_URL = '<https://gmgn.ai/defi/router/v1/sol/tx/get_swap_route?token_in_address=${inputToken}&token_out_address=${outputToken}&in_amount=${amount}&from_address=${fromAddress}&slippage=${slippage}>'

# Telegram Bot credentials
BOT_TOKEN = 'YOUR_TELEGRAM_BOT_TOKEN'
CHAT_ID = 'YOUR_CHAT_ID'

# Solanasniffer API URL
SOLSNIFFER_API_URL = "https://api.solsniffer.com/token/"


def setup_api():
    auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
    auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
    api = tweepy.API(auth, wait_on_rate_limit=True)
    return api


def create_list(api, name, description, mode='private'):
    try:
        new_list = api.create_list(name=name, mode=mode, description=description)
        return new_list
    except tweepy.TweepError as e:
        print(f"Error creating list: {e}")
        return None


def add_to_list(api, list_id, user_id):
    try:
        api.add_list_member(list_id=list_id, user_id=user_id)
    except tweepy.TweepError as e:
        print(f"Error adding user to list: {e}")


def search_and_add_users(api, list_id, query, max_users=10):
    for user in tweepy.Cursor(api.search_users, q=query, count=20).items(max_users):
        add_to_list(api, list_id, user.id)
        print(f"Added user: {user.screen_name}")
        time.sleep(1)  # To avoid hitting API rate limits too quickly


def fetch_gmgn_data(contract_address):
    headers = {'Authorization': f'Bearer {GMGN_API_KEY}'}
    response = requests.get(f"{GMGN_API_URL}/token/{contract_address}", headers=headers)
    if response.status_code == 200:
        return response.json()
    return None


def fetch_twitter_data(ticker, api):
    tweets = []
    for tweet in tweepy.Cursor(api.search_tweets, q=ticker, tweet_mode='extended').items(100):
        tweets.append(tweet)

    # Here, you would process tweets to extract metrics like sentiment, engagement
    # This is a placeholder for actual implementation
    return pd.DataFrame({'tweet_text': [tweet.full_text for tweet in tweets]})


def preprocess_data(gmgn_data, twitter_data):
    df = pd.DataFrame(gmgn_data, index=[0])
    df = pd.concat([df, twitter_data], axis=1)

    # Example features:
    df['price_change'] = df['current_price'] - df.get('previous_price', 0)
    df['sentiment_score'] = df['tweet_text'].apply(lambda x: TextBlob(x).sentiment.polarity)
    df['engagement_rate'] = 0  # Placeholder for engagement metrics

    # Normalize features
    scaler = StandardScaler()
    features = ['price_change', 'sentiment_score']  # Adjust according to actual features
    df[features] = scaler.fit_transform(df[features])

    return df


def train_model(data):
    X = data.drop(['success_metric'], axis=1, errors='ignore')
    y = data['success_metric'] if 'success_metric' in data.columns else data['price_change']
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

    model = RandomForestRegressor(n_estimators=100, random_state=42)
    model.fit(X_train, y_train)

    y_pred = model.predict(X_test)
    print("MSE:", mean_squared_error(y_test, y_pred))
    print("R2 Score:", r2_score(y_test, y_pred))

    return model


def verify_contract_safety(contract_address):
    try:
        response = requests.get(f"{SOLSNIFFER_API_URL}{contract_address}")
        response.raise_for_status()
        data = response.json()
        safety_rating = data.get('safetyRating', 'Unknown')
        safety_score = data.get('safetyScore', 0)
        return safety_rating, safety_score
    except requests.RequestException as e:
        print(f"Error fetching safety data for {contract_address}: {e}")
        return "Unknown", 0


def check_safety_and_alert(context: CallbackContext):
    bot = context.bot
    job = context.job
    contract_address = job.context

    safety_rating, safety_score = verify_contract_safety(contract_address)

    if safety_rating.lower() != "good" and safety_score < 70:
        message = f"Alert: Safety rating for token {contract_address} has dropped to {safety_rating} with a score of {safety_score}."
        bot.send_message(chat_id=CHAT_ID, text=message)
    else:
        print(f"Safety check for {contract_address}: {safety_rating}, Score: {safety_score}")


def add_safety_check_job(context: CallbackContext, contract_address):
    context.job_queue.run_repeating(check_safety_and_alert, interval=3600, first=0, context=contract_address)


def send_token_to_bot(contract_address):
    url = f'https://api.telegram.org/bot{BOT_TOKEN}/sendMessage'
    data = {
        'chat_id': CHAT_ID,
        'text': f"New vetted token: {contract_address}"
    }

    response = requests.post(url, data=data)
    if response.status_code != 200:
        print(f'Failed to send message: {response.content}')
    else:
        print(f'Successfully sent message for token: {contract_address}')


def add_monitor_command(update: Update, context: CallbackContext):
    if len(context.args) != 1:
        update.message.reply_text("Usage: /add_monitor <contract_address>")
        return

    contract_address = context.args[0]
    add_safety_check_job(context, contract_address)
    update.message.reply_text(f"Monitoring started for contract {contract_address}")


def main():
    api = setup_api()

    # Create Telegram bot updater
    updater = Updater(BOT_TOKEN, use_context=True)
    dispatcher = updater.dispatcher
    job_queue = updater.job_queue

    # Setup Telegram bot commands
    dispatcher.add_handler(CommandHandler("add_monitor", add_monitor_command))

    # Example of monitoring a contract (just for demonstration)
    add_safety_check_job(CallbackContext(job_queue), "0x1234567890abcdef...")

    # Start the bot
    updater.start_polling()

    # Monitor X for tokens
    influencers = ['KOL_Handle1', 'KOL_Handle2']
    keywords = ['new memecoin', 'pumpfun launch']

    list_name = "Crypto Influencers"
    list_description = "Prominent figures in the crypto space."
    new_list = create_list(api, list_name, list_description)

    if new_list:
        print(f"List created: {new_list.name}")
        search_and_add_users(api, new_list.id, ' OR '.join(keywords), max_users=10)

        while True:  # Continuous monitoring
            monitor_tweets(api, influencers, keywords)
            time.sleep(60)  # Wait for a minute before next search to avoid hitting rate limits
    else:
        print("Failed to create list.")


if __name__ == "__main__":
    main()