import sys
import random
import datetime
import time
import threading

import discord
import sqlite3

import interface

secrets_file = open(sys.argv[1], mode="rt")
secrets = secrets_file.read()
secrets_file.close()

token = secrets

intents = discord.Intents.default()
intents.message_content = True
intents.members = True
intents.moderation = True

client = discord.Client(intents=intents, activity=discord.Game(name='En train de niquer des mères'))

interface.client = client

import forgejo

database = sqlite3.connect(sys.argv[2])
cursor = database.cursor()

#try:
#  cursor.execute("CREATE TABLE casino (id INT PRIMARY KEY, cash INT)")
#  database.commit()
#except:
#  print("La table existe déja")

guilds = []

globals()["gmembers"] = {}

async def pinguncon(message):
  #fcalva's server
  if message.guild.id == 750665878072328242:
    await message.channel.send("<@499533339468759052>")
  elif message.guild.id in [1008485562304450610, 1157767629738618941]:
    await message.channel.send("<@755081785393676328>")
  elif message.guild.id == 1294017120631525416:
    await message.channel.send("<@504751919760408617>")
  else:
    await message.channel.send("Pas dispo ici")

async def pingjuif(message):
    if message.guild.id in [1008485562304450610, 1157767629738618941]:
      await message.channel.send("<@459021187083927553>")
    else:
      message.channel.send("Pas dispo ici")

async def pingrand(message):
  choice = random.choice(globals()["gmembers"][str(message.guild.id)])
  await message.channel.send("<@"+str(choice.id)+">")

async def roulette(message):
  roll = random.random()
  if roll < 0.16666666666:
    tdelt = datetime.timedelta(minutes=1)
    try:
      await message.author.timeout(tdelt, reason="Vous avez perdu à la roulette...")
    except:
      await message.channel.send("Une erreur s'est produite ! (Je ne peux probablement pas vous timeout)")
  else:
    await message.channel.send("Ouf ! Il n'y avait pas de cartouche dans la chambre...")

async def casino_init(message):
  usrid = int(message.author.id)
  gid = int(message.guild.id)
  try:
    cursor.execute(f"CREATE TABLE IF NOT EXISTS tab_{gid} (id INT PRIMARY KEY, cash INT, lst_coll INT)")
    cursor.execute(f"INSERT INTO tab_{gid} (id, cash, lst_coll) VALUES ({usrid}, 0, 0)")
    database.commit()
    await message.channel.send(f"Casino initialisé pour <@{usrid}>")
  except:
    await message.channel.send(f"Échec ! Réessayez plus tard")

init_global_str = "Essayer d'initialiser le casino du serveur avec ?init"
init_perso_str = "Essayez d'initialiser votre portemonnaie avec ?init"

async def balance(message):
  usrid = int(message.author.id)
  gid = int(message.guild.id)
  try:
    cash = cursor.execute(f"SELECT cash FROM tab_{gid} WHERE id={usrid}").fetchone()
  except:
    await message.channel.send(init_global_str)
  if cash != None:
    await message.channel.send(f"Vous avez {cash[0]}$")
  else:
    await message.channel.send(init_perso_str)

async def collect(message):
  collect_gain = 50
  cooldown = 10
  curr_time = int(time.time())
  usrid = int(message.author.id)
  gid = int(message.guild.id)
  lst_coll = 0
  try:
    lst_coll = cursor.execute(f"SELECT lst_coll FROM tab_{gid} WHERE id={usrid}").fetchone()[0]
  except:
    await message.channel.send(init_perso_str)
    return
  if lst_coll >= curr_time - cooldown:
    rtime = (-curr_time + cooldown + lst_coll)
    await message.channel.send(f"Vous pourrez toucher votre RSA dans {rtime} minutes")
    return
  cash = None
  cash = cursor.execute(f"SELECT cash FROM tab_{gid} WHERE id={usrid}").fetchone()
  if cash != None:
    cash = cash[0]
    cash += collect_gain
    cursor.execute(f"UPDATE tab_{gid} SET lst_coll = {curr_time} WHERE id={usrid}")
    cursor.execute(f"UPDATE tab_{gid} SET cash = {cash} WHERE id={usrid}")
    database.commit()
    await message.channel.send(f"Vous avez recu {collect_gain}$ en RSA. Vous avez désormais {cash}$\n"\
                               f"Revenez dans {cooldown} minutes pour votre prochain chèque")
  else:
    await message.channel.send(init_perso_str)

async def ecoaide(message):
  await message.channel.send("Eco+, un bot Eco plus pour faire des conneries\n"\
                              "?pinguncon : Ping le con local\n"\
                              "?pingunjuif : Ping le juif local\n"\
                              "?pingrand : Ping un membre aléatoire du serveur\n"
                              "?roulette : Prennez une chance sur six de vous faire timeout")

async def ecohelp(message):
  await message.channel.send("Eco+ help page \n"\
                             "?pinguncon : Ping the local dumbass\n"\
                             "?pingrand : Ping a random user\n"\
                             "?roulette : Take one shot on six to get timed out")

async def hello(message):
  await message.channel.send('henlo')

commentaires_zizi = [
  #0
  ["Vous avez essayé de mesurer à la base ?","Dur d'avoir des chromosomes XX. Retourne à la cuisine"],\
  #1
  ["J'ai pitié.", "Échec critique !"],\
  #2
  ["Tu peux toujours te dire que la taille ne compte pas"],\
  #3
  ["Dire que c'était ma taille à trois ans..."],\
  #4
  ["Retourne dans ton 4x4 micropénis"],\
  #5
  ["En impérial, ça aurait été la moyenne"],\
  #6
  ["T'es pas la bite la plus dure du gloryhole"],\
  #7
  [""],\
  #8
  [""],\
  #9
  [""],\
  #10
  [""],\
  #11
  [""],\
  #12
  [""],\
  #13
  ["La moyenne, pour de vrai"],\
  #14
  [""],\
  #15
  [""],\
  #16
  ["La verité est dure à avaler"],\
  #17
  ["C'est roc, c'est un pic, c'est un cap. Que dis-je ? C'est une péninsule"],\
  #18
  ["Si le goût se rapporte à la taille, vous êtes le phoenix des hôtes du gang bang"],\
  #19
  ["Bien membré !"],\
  #20
  ["Je veux la même !", "Coup critique !"],\
  #21
  ["Profite de tes chromosomes YY :moai:", "La taille moyenne en Uganda"]
]

async def zizi(message):
  id = message.author.id
  size = random.randint(0,10) + random.randint(0,11)
  comment = random.choice(commentaires_zizi[size])
  await message.channel.send(f"<@{id}>, votre chibre fait **{size} cm**. {comment}")

@client.event
async def on_ready():
  print(f'We have logged in as {client.user}')
  async for guild in client.fetch_guilds(limit=150):
    print(str(guild.id)+":")
    guilds.append(guild)
    sid = str(guild.id)
    globals()["gmembers"] |= {sid:[]}
    async for member in guild.fetch_members(limit=150):
      globals()["gmembers"][sid].append(member)
      print("  "+str(member))

cmd_dict = {\
  "?hello":hello,\
  "?pinguncon":pinguncon,\
  "?pingrand":pingrand,\
  "?pingunjuif":pingjuif,\
  "?zizi":zizi,\
  "?roulette":roulette,\
  "?help":ecohelp,\
  "?aide":ecoaide,\
  "?init":casino_init,\
  "?cash":balance,\
  "?collect":collect,\
}

@client.event
async def on_message(message):
  if message.author == client.user:
    return

  content = message.content

  if not content:
    return
  if content[0] != "?":
    return

  try:
    await cmd_dict[content](message)
  except Exception as err:
    print(err)
    await message.channel.send("Commande non reconnue !")

def do_forgejo_thread():
  print("229")
  forgejo.app.run(port=5000)

forgejo_thread = threading.Thread()
forgejo_thread.run = do_forgejo_thread 

print("227")
forgejo_thread.start()
client.run(token)