import os
import io
import re
import csv
import sys
import json
import time
import random
import asyncio
import discord
import logging
import os.path
import secrets
import aiohttp
import gspread
import datetime
import schedule
import requests
import threading
import gradio_client

import numpy as np
import pandas as pd
import gradio as gr
import plotly.graph_objects as go

from tabulate import tabulate
from requests import HTTPError
from gradio_client import Client
from discord import Color, Embed
from discord.ui import Button, View
from discord.ext import commands, tasks
from datetime import datetime, timedelta
from urllib.parse import urlparse, parse_qs
from apscheduler.executors.pool import ThreadPoolExecutor
from apscheduler.executors.asyncio import AsyncIOExecutor
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from gspread_formatting.dataframe import format_with_dataframe
from apscheduler.schedulers.background import BackgroundScheduler
from gspread_dataframe import get_as_dataframe, set_with_dataframe
from huggingface_hub import HfApi, list_liked_repos, list_models


DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
intents = discord.Intents.all() 
bot = commands.Bot(command_prefix='!', intents=intents)


## testing restart
def restart_bot():
    print("Restarting bot...")
    os.execv(sys.executable, ['python'] + sys.argv)


@bot.event
async def on_ready():
    """import data from google sheets -> HF Space df (doesn't make API call this way, as it's read-only)""" 
    print(f"We have logged in as {bot.user}")
    await give_verified_roles()


async def give_verified_roles():
    while True:
        try:
            global_df = pd.DataFrame()

            async with aiohttp.ClientSession() as session:
                try:
                    async with session.get(
                        "https://docs.google.com/spreadsheets/d/1C8aLqgCqLYcMiIFf-P_Aosaa03C_WLIB_UyqvjSdWg8/export?format=csv&gid=0",
                        timeout=10
                    ) as response:
                        if response.status != 200:
                            print(f"Failed to fetch CSV: HTTP {response.status}")
                            await asyncio.sleep(60)
                            continue
                        csv_data = await response.text()
                        global_df = pd.read_csv(io.StringIO(csv_data))
                except asyncio.TimeoutError:
                    print("CSV fetch timed out.")
                    await asyncio.sleep(60)
                    continue
                except Exception as e:
                    print(f"Error fetching CSV: {e}")
                    await asyncio.sleep(60)
                    continue
 
            guild = bot.get_guild(879548962464493619)
            role = guild.get_role(900063512829755413)
    
            # Define the invite message
            org_link = "https://huggingface.co/organizations/discord-community/share/wPKRAHYbAlaEaCxUxcqVyaaaeZcYagDvqc"
            invite_message = "Click to join our community org on the HF Hub!"

            # Cache members in the guild
            await guild.chunk()
    
            # Iterate over the dataframe rows
            for index, row in global_df.iterrows():
                # Extract Hugging Face username
                hf_user_name = row['hf_user_name']
                if pd.notna(hf_user_name) and hf_user_name.lower() != 'n/a':
                    discord_id = row['discord_user_id'].strip('L')
                    member = guild.get_member(int(discord_id))
                    if not member:
                        continue
                    if role not in member.roles:
                        await member.add_roles(role)
                        await asyncio.sleep(5)
                        print(f"Role added to member: {member}")
                        #await asyncio.sleep(10)
                        lunar = bot.get_user(811235357663297546)
                        if lunar:
                            await lunar.send(f"Verified role given to {member}!") 
                        await member.send(
                            f"Verification successful! [{member} <---> {row['discord_user_name']}] \n🤗 {org_link} {invite_message}"
                        )
                        await asyncio.sleep(5)
    
        except Exception as e:
            print(f"Error encountered: {e}")
        await asyncio.sleep(30) # was 60

        
# Function to run the bot in a thread
def run_bot():
    bot.run(DISCORD_TOKEN)


# Function to schedule the bot restart at midnight
def schedule_restart():
    schedule.every().day.at("00:00").do(restart_bot)

    while True:
        schedule.run_pending()
        time.sleep(1)


# Launch the bot and restart scheduler in separate threads
threading.Thread(target=run_bot).start()
threading.Thread(target=schedule_restart).start()


# Example Gradio interface
def greet(name):
    return "Hello " + name + "!"
demo = gr.Interface(fn=greet, inputs="text", outputs="text")
demo.launch()