using System;
using System.IO;
using System.Threading;
using System.Collections.Generic;
using MCGalaxy;

public class CmdTransition : Command {

    const string DirName  = "TRANSITION";
    const string FileName = "usable.txt";


    static readonly List<string> usableCommands = new List<string>();


    static readonly string usableFilePath;

    static CmdTransition() {
        try {

            string configDir    = Path.Combine("Config", DirName);
            usableFilePath      = Path.Combine(configDir, FileName);

            if (!Directory.Exists(configDir)) {
                Directory.CreateDirectory(configDir);
            }
            if (!File.Exists(usableFilePath)) {
                File.WriteAllText(usableFilePath, "");
            }


            foreach (string line in File.ReadAllLines(usableFilePath)) {
                string cmd = line.Trim().ToLowerInvariant();
                if (cmd.Length > 0 && !usableCommands.Contains(cmd)) {
                    usableCommands.Add(cmd);
                }
            }
        }
        catch {

        }
    }

    public override string name          { get { return "transition"; } }
    public override string shortcut      { get { return "";           } }
    public override string type          { get { return "mod";        } }
    public override LevelPermission defaultRank { get { return LevelPermission.Operator; } }
    public override bool museumUsable    { get { return false;        } }

    public override void Use(Player p, string message) {
        if (message == null) message = "";


        string[] firstSplit = message.Split(new char[] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
        if (firstSplit.Length >= 1 && firstSplit[0].Equals("add", StringComparison.OrdinalIgnoreCase)) {

            if (firstSplit.Length < 2) {
                p.Message("&cUsage: /transition add <commandName>");
                return;
            }
            if (p.Rank < LevelPermission.Owner) {
                p.Message("&cOnly Owner (or higher) may add usable commands."); //too laaaazyyy to add this as an extra perm :3
                return;
            }

            string cmdToAdd = firstSplit[1].Trim().ToLowerInvariant();
            Command found = Command.Find(cmdToAdd);
            if (found == null) {
                p.Message("&cNuh huh, \"{0}\": no such command exists.", cmdToAdd);
                return;
            }
            if (usableCommands.Contains(cmdToAdd)) {
                p.Message("&cCommand \"{0}\" is already enabled. (don't bother) ", cmdToAdd);
                return;
            }

            try {
                File.AppendAllText(usableFilePath, cmdToAdd + Environment.NewLine);
                usableCommands.Add(cmdToAdd);
                p.Message("&aCommand \"{0}\" has been enabled!", cmdToAdd);
            }
            catch (Exception ex) {
                p.Message("&c(Ouch) Failed to add command: {0}", ex.Message);
            }
            return;
        }


        string[] parts = message.Split(new char[] { ' ' }, 9);
        if (parts.Length < 8) {
            Help(p);
            return;
        }


        byte r, g, b, targetAlpha;
        int skipAmount, intervalMs;
        if (!byte.TryParse(parts[0], out r) ||
            !byte.TryParse(parts[1], out g) ||
            !byte.TryParse(parts[2], out b) ||
            !byte.TryParse(parts[3], out targetAlpha) ||
            !int.TryParse(parts[4], out skipAmount) ||
            !int.TryParse(parts[5], out intervalMs))
        {
            p.Message("&cUsage: /transition <R> <G> <B> <targetAlpha> <skipAmount> <intervalMs> <fadeOut> <when> [command...]");
            p.Message("&cR, G, B, targetAlpha must be 0–255. skipAmount & intervalMs must be positive integers.");
            return;
        }
        if (skipAmount <= 0) {
            p.Message("&cskipAmount must be greater than 0.");
            return;
        }
        if (intervalMs <= 0) {
            p.Message("&cintervalMs must be greater than 0.");
            return;
        }


        bool fadeOutFlag;
        if (!bool.TryParse(parts[6], out fadeOutFlag)) {
            p.Message("&cfadeOut must be either true or false.");
            return;
        }


        string whenRaw = parts[7].ToLowerInvariant();
        bool runNow;
        if (whenRaw == "now") {
            runNow = true;
        } else if (whenRaw == "after") {
            runNow = false;
        } else {
            p.Message("&cThe <when> parameter must be either \"now\" or \"after\".");
            return;
        }


        string afterCommand = "";
        if (parts.Length == 9) {
            afterCommand = parts[8].Trim();
        }

        Command cmd = null;
        string cmdName = "";
        string cmdArgs = "";

        if (afterCommand.Length > 0) {

            string cmdLine = afterCommand.StartsWith("/") ? afterCommand.Substring(1) : afterCommand;
            string[] cmdParts = cmdLine.Split(new char[] { ' ' }, 2);
            cmdName = cmdParts[0].ToLowerInvariant();
            cmdArgs = (cmdParts.Length > 1) ? cmdParts[1] : "";


            if (!usableCommands.Contains(cmdName)) {
                p.Message("&cThe command \"{0}\" is not enabled for /transition. Use &e/transition add {0}&c to enable it!!!!!!", cmdName);
                return;
            }


            cmd = Command.Find(cmdName);
            if (cmd == null) {
                p.Message("&c(Ouch) Unknown command: \"{0}\"", cmdName);
                return;
            }
            if (p.Rank < cmd.defaultRank) {
                p.Message("&cYou do not have permission to run /{0}.", cmdName);
                return;
            }
        }

        new Thread(delegate () {
            DoTransition(p, r, g, b, targetAlpha, skipAmount, intervalMs, fadeOutFlag, runNow, cmd, cmdArgs);
        }).Start();
    }

    static void DoTransition(Player p, byte r, byte g, byte b, byte targetAlpha,
                             int skipAmount, int intervalMs,
                             bool fadeOutFlag, bool runNow,
                             Command cmd, string cmdArgs)
    {
        try {
            byte alpha = 0;


            while (true) {
                if (alpha > targetAlpha) alpha = targetAlpha;

                byte[] packet = new byte[] { 56, 0, 0, 0, r, g, b, alpha, 255, 255 };
                p.Session.Send(packet);

                if (alpha == targetAlpha) break;

                Thread.Sleep(intervalMs);
                int next = alpha + skipAmount;
                alpha = (byte)(next > targetAlpha ? targetAlpha : next);
            }
            if (runNow && cmd != null) {
                cmd.Use(p, cmdArgs, new CommandData());
            }


            if (fadeOutFlag) {

                while (true) {
                    if (alpha == 0) break;

                    int next = alpha - skipAmount;
                    alpha = (byte)(next < 0 ? 0 : next);


                    byte[] packet = new byte[] { 56, 0, 0, 0, r, g, b, alpha, 255, 255 };
                    p.Session.Send(packet);

                    if (alpha == 0) break;
                    Thread.Sleep(intervalMs);
                }


                if (!runNow && cmd != null) {
                    cmd.Use(p, cmdArgs, new CommandData());
                }


                byte[] resetPkt = new byte[] { 56, 0, 0, 0, r, g, b, 0, 255, 255 };
                p.Session.Send(resetPkt);
            }
            else {

                if (!runNow && cmd != null) {

                    Thread.Sleep(1000);
                    cmd.Use(p, cmdArgs, new CommandData());
                } else {

                    Thread.Sleep(1000);
                }


                byte[] resetPkt = new byte[] { 56, 0, 0, 0, r, g, b, 0, 255, 255 };
                p.Session.Send(resetPkt);
            }
        }
        catch {

        }
    }

    public override void Help(Player p) {
        p.Message("&HUsage:");
        p.Message("&e/transition add <commandName>");
        p.Message("&7Adds <commandName> to the list of commands enabled for /transition. Only Owner+ may do this.");
        p.Message("&7I was too lazy to add /transition remove <commandName>.");
        p.Message("&e/transition <R> <G> <B> <targetAlpha> <skipAmount> <intervalMs> <fadeOut> <when> [command...]");
    }
}