# dummy module
import os
import random
from concurrent.futures import ThreadPoolExecutor

import discord
import fractale.source.main
from PIL import Image


class MainClass():
    def __init__(self, client, modules, owners, prefix):
        self.client = client
        self.modules = modules
        self.owners = owners
        self.prefix = prefix
        self.events = ['on_message']  # events list
        self.command = "%sfractale" % self.prefix  # command prefix (can be empty to catch every single messages)

        self.name = "Fractale"
        self.description = "Module de génération de fractales"
        self.interactive = True
        self.color = 0x78ffc3
        self.fractals = {
            "von_koch_curve_flake": {"Type": "Figures", "Max": ((5000, 5000), 5000, 10), "Min": ((0, 0), 0, 1),
                                     "Default": "(2500 2500) 2000 5 #ffffff 1",
                                     "Indication": "(départ) (arrivée) longueur iterations color bg stroke",
                                     "ParseData": "pfixi"},
            "von_koch_curve": {"Type": "Figures", "Max": ((5000, 5000), (5000, 5000), 10), "Min": ((0, 0), (0, 0), 1),
                               "Default": "(0 2500) (5000 2500) 5 #ffffff 1",
                               "Indication": "(départ) (arrivée) iterations color bg stroke", "ParseData": "ppixi"},
            "blanc_manger": {"Type": "Figures", "Max": ((5000, 5000), (5000, 5000), 10), "Min": ((0, 0), (0, 0), 1),
                             "Default": "(1000 1000) (4000 4000) 7 #ffffff 1",
                             "Indication": "(départ) (arrivée) iterations color bg stroke", "ParseData": "ppixi"},
            "dragon": {"Type": "Lsystem", "Max": ((5000, 5000), 2500, 19), "Min": ((0, 0), 1, 1),
                       "Default": "(2500 2500)", "Indication": "(origine) longueur iterations color bg stroke",
                       "ParseData": "pfixi"},
            "sierpinski_triangle": {"Type": "Lsystem", "Max": ((5000, 5000), 2500, 11), "Min": ((0, 0), 0, 1),
                                    "Default": "(0 0)", "Indication": "(origine) longueur iterations color bg stroke",
                                    "ParseData": "pfixi"},
            "fractal_plant": {"Type": "Lsystem", "Max": ((5000, 5000), 2500, 8), "Min": ((0, 0), 0, 1),
                              "Default": "(0 2500)", "Indication": "(origine) longueur iterations color bg stroke",
                              "ParseData": "pfixi"},
            "koch_curve_right_angle": {"Type": "Lsystem", "Max": ((5000, 5000), 2500, 9), "Min": ((0, 0), 0, 1),
                                       "Default": "(0 5000)",
                                       "Indication": "(origine) longueur iterations color bg stroke",
                                       "ParseData": "pfixi"},
            "fractal_binary_tree": {"Type": "Lsystem", "Max": ((5000, 5000), 2500, 15), "Min": ((0, 0), 0, 1),
                                    "Default": "(0 0)", "Indication": "(origine) longueur iterations color bg stroke",
                                    "ParseData": "pfixi"}
        }
        self.help = """\
 </prefix>fractale [fractale] [nombre d'itérations]
 => Génère une image fractale. (Si on met le nombre d'itérations, on doit mettre le nom de la fractale.)
 
 -> Valeurs possible pour [fractale]
```..: Toutes les fractales:
%s```""" % '\n'.join(['......: %s' % t for t in self.fractals.keys()])

    def parse(self, inp):
        retDic = {"Success": False, "Message": "", "Result": ()}
        # Parsing the fractal name and storing the corresponding dic into a variable
        try:
            fractal = self.fractals[inp.split(' ')[0]]
        except KeyError:
            retDic.update({"Success": False, "Message": "La fractale %s n'existe pas." % inp.split(' ')[0]})
            return (retDic)
        arg = ' '.join(inp.split(' ')[1:])  # Stuff after the fractal name
        # checking for incoherent parentheses usage
        parentheses_count = 0
        for i, char in enumerate(arg):
            if char == '(':
                parentheses_count += 1
            elif char == ')':
                parentheses_count -= 1
            if not (-1 < parentheses_count < 2):
                retDic.update({"Success": False,
                               "Message": "Usage invalide de parentheses au charactère numéro %s (à partir d'après le nom de la fractale)." % i})
                return (retDic)

        # Here, we have a coherent parentheses usage
        if ',' in arg:
            retDic.update({"Success": False,
                           "Message": "Les virgules n'ont pas leur place dans les paramètres de génération. Il ne doit y avoir que des espaces uniques."})
            return (retDic)

        # parsing the fractal
        args = arg.replace(')', '').replace('(', '').split(' ')
        parsed_args = []
        i = 0
        for parse in fractal['ParseData']:
            if parse == 'p':
                if args[i] != '*':
                    try:
                        int(args[i])
                        int(args[i + 1])
                    except:
                        retDic.update({"Success": False,
                                       "Message": "Les valeurs ne sont pas du bon type. (nombre entiers attendus pour les coordonnées d'un point)"})
                        return (retDic)
                    parsed_args.append((int(args[i]), int(args[i + 1])))
                    i += 2
                else:
                    parsed_args.append(
                        self.parse(inp.split(' ')[0] + ' ' + fractal['Default'])['Result'][len(parsed_args)])
                    i += 1

            elif parse == 'f':
                if args[i] != '*':
                    try:
                        float(args[i])
                    except:
                        retDic.update({"Success": False,
                                       "Message": "Les valeurs ne sont pas du bon type. (Nombre à virgule flottante attendu (mettre un point pour la virgule))"})
                        return (retDic)
                    parsed_args.append(float(args[i]))
                    i += 1
                else:
                    parsed_args.append(
                        self.parse(inp.split(' ')[0] + ' ' + fractal['Default'])['Result'][len(parsed_args)])
                    i += 1

            elif parse == 'i':
                if args[i] != '*':
                    try:
                        int(args[i])
                    except:
                        print(args[i])
                        print(i)
                        retDic.update({"Success": False,
                                       "Message": "Les valeurs ne sont pas du bon type. (Nombre entier attendu)"})
                        return (retDic)
                    parsed_args.append(int(args[i]))
                    i += 1
                else:
                    parsed_args.append(
                        self.parse(inp.split(' ')[0] + ' ' + fractal['Default'])['Result'][len(parsed_args)])
                    i += 1

            elif parse == 'x':
                if args[i] != '*':
                    try:
                        if '#' in args[i]:
                            int(args[i].replace('#', '0x'), 16)
                        else:
                            raise
                    except:
                        retDic.update({"Success": False,
                                       "Message": "Les valeurs ne sont pas du bon type. (Valeur hexadécimale attendue)"})
                        return (retDic)
                    parsed_args.append(int(args[i].replace('#', '0x'), 16))
                    i += 1
                else:
                    parsed_args.append(
                        self.parse(inp.split(' ')[0] + ' ' + fractal['Default'])['Result'][len(parsed_args)])
                    i += 1
        retDic.update({"Success": True, "Result": parsed_args})
        return (retDic)

    async def on_message(self, message):
        # await message.channel.send(str(self.parse(message.content[len("%sfractale "%self.prefix):])))
        # ħere
        args = message.content.split(" ")
        tmpstr = "/tmp/%s.png" % random.randint(1, 10000000)
        im = Image.new('RGB', (5000, 5000), (0, 0, 0))  # here

        fig = fractale.source.main.Figures(im=im)  # here
        if len(args) == 1:
            await self.client.loop.run_in_executor(ThreadPoolExecutor(), fig.von_koch_curve_flake,
                                                   *((2500, 2500), 2000, 5))
        elif args[1].lower() == "blanc_manger":
            iterations = 7
            if len(args) > 2 and int(args[2]) <= 20:
                iterations = int(args[2])
            await self.client.loop.run_in_executor(ThreadPoolExecutor(), fig.blanc_manger,
                                                   *((1000, 1000), (4000, 4000), iterations))
        elif args[1].lower() == "von_koch_curve_flake":
            iterations = 5
            if len(args) > 2 and int(args[2]) <= 7:
                iterations = int(args[2])
            await self.client.loop.run_in_executor(ThreadPoolExecutor(), fig.von_koch_curve_flake,
                                                   *((2500, 2500), 2000, iterations))
        elif args[1].lower() == "von_koch_curve":
            iterations = 5
            if len(args) > 2 and int(args[2]) <= 7:
                iterations = int(args[2])
            await self.client.loop.run_in_executor(ThreadPoolExecutor(), fig.von_koch_curve,
                                                   *((0, 2500), (5000, 2500), iterations))
        else:
            await self.modules['help'][1].send_help(message.channel, self)
            return  # here
        im.save(tmpstr)  # here
        await message.channel.send(file=discord.File(tmpstr))
        os.remove(tmpstr)  # here