using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Mail;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace EuroMillionsAI
{
    class Smtp
    {
        public string Client { get; set; }
        public string Email { get; set; }
        public string Password { get; set; }
    }

    class User
    {
        public string Name { get; set; }
        public string Email { get; set; }
    }

    class Draw
    {
        public DateTime Date { get; set; }
        public string Numbers { get; set; }
        public string Stars { get; set; }
    }

    class DrawnsLists
    {
        public List<Draw> Drawns { get; set; }
    }

    class DrawnsStats
    {
        public double Average { get; set; }
        public double StandardDeviation { get; set; }
        public double LowerBracket { get; set; }
        public double UpperBracket { get; set; }
    }

    class ImprovedDraw
    {
        public int[] Numbers { get; set; }
        public int[] Stars { get; set; }
    }

    static class Program
    {
        static void Main(string[] args)
        {
            DateTime scriptStartTime = DateTime.Now;

            int usersEmailedOK = 0;
            int usersEmailedNOK = 0;

            LogExecution("############################################################");
            LogExecution("Script started at " + scriptStartTime);

            Smtp smtpServer = GetSMTPConfig();
            List<User> users = GetUsersFromJson();

            if (users.Count > 0)
            {
                var drawnsJson = GetDrawnsFromJsonAPI();

                if (drawnsJson != null)
                {
                    DrawnsLists drawnsAll = JsonConvert.DeserializeObject<DrawnsLists>(drawnsJson);

                    List<Draw> drawnsNewRules = drawnsAll.Drawns.Where(x => x.Date >= new DateTime(2016, 9, 27, 0, 0, 0)).ToList();

                    List<int> drawnsNumbersSum = new List<int>();
                    List<int> drawnsStarsSum = new List<int>();

                    int[] numbersCount = new int[50];
                    int[] starsCount = new int[12];

                    foreach (var draw in drawnsNewRules)
                    {
                        List<int> drawNumbers = draw.Numbers.Split(' ').Select(int.Parse).ToList();
                        foreach (var number in drawNumbers)
                        {
                            numbersCount[number - 1] += 1;
                        }

                        drawnsNumbersSum.Add(drawNumbers.Sum());

                        List<int> drawStars = draw.Stars.Split(' ').Select(int.Parse).ToList();
                        foreach (var star in drawStars)
                        {
                            starsCount[star - 1] += 1;
                        }

                        drawnsStarsSum.Add(drawStars.Sum());
                    }

                    double avgSumNumbers = drawnsNumbersSum.Average();
                    double sdevSumNumbers = StandardDeviation(drawnsNumbersSum);

                    double avgSumStars = drawnsStarsSum.Average();
                    double sdevSumStars = StandardDeviation(drawnsStarsSum);

                    DrawnsStats drawnsNumbersStats = new DrawnsStats()
                    {
                        Average = avgSumNumbers,
                        StandardDeviation = sdevSumNumbers,
                        LowerBracket = avgSumNumbers - sdevSumNumbers,
                        UpperBracket = avgSumNumbers + sdevSumNumbers
                    };

                    DrawnsStats drawnsStarsStats = new DrawnsStats()
                    {
                        Average = avgSumStars,
                        StandardDeviation = sdevSumStars,
                        LowerBracket = avgSumStars - sdevSumStars,
                        UpperBracket = avgSumStars + sdevSumStars
                    };

                    LogExecution(
                        "Numbers stats: AVG = " + avgSumNumbers.ToString("N2") + "; " +
                        "SDEV = " + sdevSumNumbers.ToString("N2") + "; " +
                        "[" + drawnsNumbersStats.LowerBracket.ToString("N2") + ", " + drawnsNumbersStats.UpperBracket.ToString("N2") + "]");

                    LogExecution(
                        "Stars stats: AVG = " + avgSumStars.ToString("N2") + "; " +
                        "SDEV = " + sdevSumStars.ToString("N2") + "; " +
                        "[" + drawnsStarsStats.LowerBracket.ToString("N2") + ", " + drawnsStarsStats.UpperBracket.ToString("N2") + "]");

                    foreach (var user in users)
                    {
                        DateTime userScriptStartTime = DateTime.Now;

                        LogExecution("User loop start");

                        List<ImprovedDraw> improvedDrawns = GetImprovedDrawns(5, drawnsNumbersStats, drawnsStarsStats);

                        string emailLuckyDraws = string.Empty;
                        for (int i = 0; i < 5; i++)
                        {
                            string luckyDraw = string.Join(" ", improvedDrawns[i].Numbers) + "  *  " + string.Join(" ", improvedDrawns[i].Stars);

                            emailLuckyDraws += luckyDraw + "<br/>";

                            LogCombinations(luckyDraw);
                        }

                        try
                        {
                            DateTime userScriptStopTime = DateTime.Now;
                            TimeSpan execTime = userScriptStopTime - userScriptStartTime;

                            SendEmail(
                                smtpServer.Client,
                                smtpServer.Email,
                                smtpServer.Password,
                                user.Email,
                                "Euromillions improved combinations",
                                "Hey " + user.Name + "!<br/><br/>" +
                                "Your improved random combinations were generated in " + execTime.TotalSeconds.ToString("N2") + " seconds<br/><br/>" +
                                "Combinations:<br/>" + emailLuckyDraws + "<br/><br/>" +
                                "Good luck!"
                            );

                            LogExecution("Email sent successfully");

                            usersEmailedOK++;
                        }
                        catch (Exception ex)
                        {
                            LogExecution("Error sending email");
                            LogExecution("Email: " + user.Email);
                            LogExecution("Error:");
                            LogExecution(ex.ToString());

                            usersEmailedNOK++;
                        }

                        LogExecution("User loop end");
                    }
                }
                else
                {
                    LogExecution("No data obtained from specified url");
                }
            }
            else
            {
                LogExecution("Users list is empty");
            }

            DateTime scriptStopTime = DateTime.Now;
            TimeSpan scriptExecTime = scriptStopTime - scriptStartTime;
            LogExecution("Script ended at " + scriptStopTime);
            LogExecution("Total execution time: " + scriptExecTime.TotalSeconds.ToString("N2") + " seconds");

            List<User> admins = GetAdminsFromJson();
            foreach (var admin in admins)
            {
                SendEmail(
                    smtpServer.Client,
                    smtpServer.Email,
                    smtpServer.Password,
                    admin.Email,
                    "Euromillions execution log",
                    "Euromillions execution log" +
                    "<br/><br/>" +
                    "Script started at " + scriptStartTime + "<br/>" +
                    "Ended at " + scriptStopTime + "<br/>" +
                    "Total execution time: " + scriptExecTime + "<br/><br/>" +
                    users.Count + " total users" + "<br/>" +
                    usersEmailedOK + " users emailed successfully" + "<br/>" +
                    usersEmailedNOK + " users not emailed" + "<br/><br/>" +
                    "END"
                );
            }
        }

        private static Smtp GetSMTPConfig()
        {
            Smtp smtp = new Smtp();
            using (StreamReader r = new StreamReader("smtp.json"))
            {
                string smtpJson = r.ReadToEnd();
                smtp = JsonConvert.DeserializeObject<Smtp>(smtpJson);
            }

            return smtp;
        }

        private static List<User> GetAdminsFromJson()
        {
            List<User> admins = new List<User>();
            using (StreamReader r = new StreamReader("admins.json"))
            {
                string adminsJson = r.ReadToEnd();
                admins = JsonConvert.DeserializeObject<List<User>>(adminsJson);
            }

            return admins;
        }

        private static List<User> GetUsersFromJson()
        {
            List<User> subscribers = new List<User>();
            using (StreamReader r = new StreamReader("subscribers.json"))
            {
                string subscribersJson = r.ReadToEnd();
                subscribers = JsonConvert.DeserializeObject<List<User>>(subscribersJson);
            }

            return subscribers;
        }

        private static string GetDrawnsFromJsonAPI()
        {
            string urlAPI = @"https://nunofcguerreiro.com/api-euromillions-json?result=all";

            var json = string.Empty;

            using (WebClient wc = new WebClient())
            {
                json = wc.DownloadString(urlAPI);
            }

            return json;
        }

        private static DrawnsStats CalculateDrawnsStats(List<Draw> drawnsList)
        {
            DrawnsStats drawnsStats = new DrawnsStats();

            return drawnsStats;
        }

        private static int[] PopulateArrayConsecutively(int length)
        {
            int[] resArr = new int[length];
            for (int i = 0; i < length; i++)
            {
                resArr[i] = i + 1;
            }

            return resArr;
        }

        private static List<int> GetDrawnsSum(List<Draw> drawns)
        {
            List<int> drawnsSum = new List<int>();

            foreach (Draw draw in drawns)
            {
                List<int> drawNumbers = draw.Numbers.Split(' ').Select(int.Parse).ToList();
                drawnsSum.Add(drawNumbers.Sum());
            }

            return drawnsSum;
        }

        private static double StandardDeviation(this IEnumerable<int> values)
        {
            double avg = values.Average();

            return Math.Sqrt(values.Average(v => Math.Pow(v - avg, 2)));
        }

        private static int[] FisherYatesShuffle(int[] data)
        {
            int[] retVal = new int[data.Length];
            int[] ind = new int[data.Length];
            int index;
            Random rand = new Random();

            for (int i = 0; i < data.Length; ++i)
            {
                ind[i] = 0;
            }

            for (int i = 0; i < data.Length; ++i)
            {
                do
                {
                    index = rand.Next(data.Length);
                } while (ind[index] != 0);

                ind[index] = 1;
                retVal[i] = data[index];
            }

            return retVal;
        }

        private static int[] GetRandomNumbersSorted(int[] data, int numbers)
        {
            int[] retArr = FisherYatesShuffle(data).Take(numbers).OrderBy(x => x).ToArray();

            return retArr;
        }

        private static int[] GetImprovedNumbers(int length, int numbers, double lowerBracket, double upperBracket)
        {
            int[] improvedNumbers = new int[numbers];

            while (true)
            {
                improvedNumbers = GetRandomNumbersSorted(PopulateArrayConsecutively(length), numbers);
                if (improvedNumbers.Sum() >= lowerBracket && improvedNumbers.Sum() <= upperBracket)
                {
                    break;
                }
            }

            return improvedNumbers;
        }

        private static List<ImprovedDraw> GetImprovedDrawns(int loops, DrawnsStats drawnsNumbersStats, DrawnsStats drawnsStarsStats)
        {
            List<ImprovedDraw> improvedDraws = new List<ImprovedDraw>();

            for (int i = 0; i < loops; i++)
            {
                ImprovedDraw draw = new ImprovedDraw
                {
                    Numbers = GetImprovedNumbers(50, 5, drawnsNumbersStats.LowerBracket, drawnsNumbersStats.UpperBracket),
                    Stars = GetImprovedNumbers(12, 2, drawnsStarsStats.LowerBracket, drawnsStarsStats.UpperBracket)
                };

                improvedDraws.Add(draw);

                Thread.Sleep(100);
            }

            return improvedDraws;
        }

        private static void SendEmail(string smtpClient, string smtpEmailAddress, string smtpEmailPassword, string userAddress, string mailTitle, string mailText)
        {
            MailMessage mail = new MailMessage();
            SmtpClient smtpServer = new SmtpClient(smtpClient);

            mail.From = new MailAddress(smtpEmailAddress);
            mail.To.Add(userAddress);
            mail.Subject = mailTitle + " " + DateTime.Now.ToString("dd/MM/yyyy");
            mail.IsBodyHtml = true;
            mail.Body = mailText;

            smtpServer.Port = 587;
            smtpServer.Credentials = new System.Net.NetworkCredential(smtpEmailAddress, smtpEmailPassword);
            smtpServer.EnableSsl = true;

            smtpServer.Send(mail);
        }

        private static void LogExecution(string log)
        {
            File.AppendAllText("Log_" + DateTime.Now.ToString("yyyyMMdd") + ".txt", string.Format("{0}{1}", "[" + DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss") + "]" + " " + log, Environment.NewLine));
        }

        private static void LogCombinations(string combinations)
        {
            File.AppendAllText("Combinations_" + DateTime.Now.ToString("yyyyMMdd") + ".txt", string.Format("{0}{1}", "[" + DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss") + "]" + " " + combinations, Environment.NewLine));
        }
    }
}