fuck you mpgh

/*
 *
 * File Name: UserAccountManager.cs
 * Initial Author: Elio Deçolli
 * Purpose: Provides a account login/register internal operation, a caching system and a EGNoSQL database management.
 * Last Code Cache Update: 27/11/2013
 *
 */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using eGamers;
using System.IO;
using System.Drawing;

// TODO: Make the cache so when it reaches a certain amount of data it will write it all into the databases to keep it safe and then reload itself.

namespace EGMasterServer2
{
    public class UserAccount
    {
        public enum UserGender
        {
            Male,
            Female,
            Potato
        }

        public enum UserStatus
        {
            Online,
            Offline,
            Away,
            Busy
        }

        private string username;
        private string password;
        private int id;
        private UserGender gender;
        private UserStatus status;
        private string ip;
        private byte[] avatar;

        public byte[] ToArray()
        {
            MemoryStream memsr = new MemoryStream();
            BinaryWriter writer = new BinaryWriter(memsr);

            // Body: Username, Password, ID, Gender, Status, IP, Avatar Length, Avatar
            writer.Write(username);
            writer.Write(password);
            writer.Write(id);
            writer.Write((int)gender);
            writer.Write((int)status);
            writer.Write(ip);
            writer.Write(avatar.Length);
            writer.Write(avatar);
            writer.Flush();

            return memsr.ToArray();
        }

        public static UserAccount Read(byte[] array)
        {
            MemoryStream memsr = new MemoryStream(array);
            BinaryReader reader = new BinaryReader(memsr);

            string u = reader.ReadString();
            string p = reader.ReadString();
            int id = reader.ReadInt32();
            UserGender gender = (UserGender)reader.ReadInt32();
            UserStatus status = (UserStatus)reader.ReadInt32();
            string ip = reader.ReadString();
            int aLen = reader.ReadInt32();
            byte[] av = reader.ReadBytes(aLen);

            return new UserAccount(u, p, id, gender, status, ip, av);
        }

        public UserAccount(string u, string p, int i, UserGender g, UserStatus s, string ipaddress, byte[] a)
        {
            username = u;
            password = p;
            id = i;
            gender = g;
            status = s;
            ip = ipaddress;
            avatar = a;
        }

        public string Username { get { return username; } set { username = value; } }
        public string Password { get { return password; } set { password = value; } }
        public int ID { get { return id; } }
        public UserGender Gender { get { return gender; } }
        public UserStatus Status { get { return status; } set { status = value; } }
        public string IP { get { return ip; } set { ip = value; } }
        public byte[] Avatar { get { return avatar; } }

        public bool IsOnline()
        {
            if (status == UserStatus.Offline)
                return false;
            return true;
        }

        public void ChangeAvatar(Image nAvatar)
        {
            MemoryStream memsr = new MemoryStream();
            nAvatar.Save(memsr, nAvatar.RawFormat);
            avatar = memsr.ToArray();
        }
    }

    public enum UserLoginResult
    {
        InvalidUsername,
        WrongPassword,
        Success
    }

    public enum UserRegisterResult
    {
        InvalidUsername,
        InvalidPassword,
        Success
    }

    public static class UserAccountManager
    {
        private static Dictionary<CachedDataType, EGNoSqlDatabase> Databases = new Dictionary<CachedDataType, EGNoSqlDatabase>();

        /*private static List<LikeCachedData> LikesCachedData = new List<LikeCachedData>();
        private static List<CommentCachedData> CommentsCachedData = new List<CommentCachedData>();
        private static List<PhotoCachedData> PhotosCachedData = new List<PhotoCachedData>();
        private static List<SocialStatusCachedData> SocialStatusesCachedData = new List<SocialStatusCachedData>();*/

        private static Dictionary<CachedDataType, CachedData> Cache = new Dictionary<CachedDataType, CachedData>();

        public static void UpdateDatabases(bool clearCache)
        {
            Log.Info("Fetching databases with cache data...");
            var comments = (from i in Cache.Values where i.Type == CachedDataType.Comments select i).ToArray();
            var likes = (from i in Cache.Values where i.Type == CachedDataType.Likes select i).ToArray();
            var photos = (from i in Cache.Values where i.Type == CachedDataType.Photos select i).ToArray();
            var socialStatuses = (from i in Cache.Values where i.Type == CachedDataType.Statuses select i).ToArray();

            foreach (var v in comments)
            {
                List<byte[]> data = new List<byte[]>();
                data.Add(v.ToArray());
                Databases[CachedDataType.Comments].AddRow(new EGNoSqlVirtualRow(new string[] { "MemCache" }, data));
            }
            foreach (var v in likes)
            {
                List<byte[]> data = new List<byte[]>();
                data.Add(v.ToArray());
                Databases[CachedDataType.Likes].AddRow(new EGNoSqlVirtualRow(new string[] { "MemCache" }, data));
            }
            foreach (var v in photos)
            {
                List<byte[]> data = new List<byte[]>();
                data.Add(v.ToArray());
                Databases[CachedDataType.Photos].AddRow(new EGNoSqlVirtualRow(new string[] { "MemCache" }, data));
            }
            foreach (var v in socialStatuses)
            {
                List<byte[]> data = new List<byte[]>();
                data.Add(v.ToArray());
                Databases[CachedDataType.Statuses].AddRow(new EGNoSqlVirtualRow(new string[] { "MemCache" }, data));
            }

            if (clearCache)
            {
                Log.Info("Clearing cache...");
                Cache.Clear();
            }
            Log.Info("Updating databases...");
            foreach (var v in Databases.Values)
            {
                v.SaveToFile();
            }
            Log.Info("Databases has been updated!");
        }

        public static void LoadCache()
        {
            if (Databases.Count == 0)
            {
                LoadDatabases();
            }

            Log.Info("Loading Cache...");
            if (Cache.Count > 0)
                Cache.Clear();

            // Update the statuses cache...
            foreach (byte[] array in Databases[CachedDataType.Statuses].FindCellData("MemCache"))
            {
                Cache.Add(CachedDataType.Statuses, CachedData.Load(array));
            }

            // Update the comments cache...
            foreach (byte[] array in Databases[CachedDataType.Comments].FindCellData("MemCache"))
            {
                Cache.Add(CachedDataType.Comments, CachedData.Load(array));
            }

            // Update the likes cache...
            foreach (byte[] array in Databases[CachedDataType.Likes].FindCellData("MemCache"))
            {
                Cache.Add(CachedDataType.Likes, CachedData.Load(array));
            }

            // Update the photos cache...
            foreach (byte[] array in Databases[CachedDataType.Photos].FindCellData("MemCache"))
            {
                Cache.Add(CachedDataType.Photos, CachedData.Load(array));
            }
            Log.Info("Loaded Cache!");
        }

        public static void LoadDatabases()
        {
            Log.Info("Loading Databases...");
            if (Databases.Count > 0)
                Databases.Clear();

            EGNoSqlDatabase users = new EGNoSqlDatabase(".\\db\\Users.db");
            EGNoSqlDatabase comments = new EGNoSqlDatabase(".\\db\\Comments.db");
            EGNoSqlDatabase likes = new EGNoSqlDatabase(".\\db\\Likes.db");
            EGNoSqlDatabase photos = new EGNoSqlDatabase(".\\db\\Photos.db");
            EGNoSqlDatabase socialStatuses = new EGNoSqlDatabase(".\\db\\SocialStatuses.db");

            Databases.Add(CachedDataType.Users, users);
            Databases.Add(CachedDataType.Comments, comments);
            Databases.Add(CachedDataType.Likes, likes);
            Databases.Add(CachedDataType.Photos, photos);
            Databases.Add(CachedDataType.Statuses, socialStatuses);

            if (Cache.Count == 0)
            {
                LoadCache();
            }

            Log.Info("Databases has been loaded!");
        }

        public static CachedData[] FindAllComments()
        {
            if (Cache.Count == 0)
            {
                LoadCache();
            }

            var comments = from CachedData i in Cache.Values where i.Type == CachedDataType.Comments select i;
            return comments.ToArray();
        }

        public static CachedData[] FindAllLikes()
        {
            if (Cache.Count == 0)
            {
                LoadCache();
            }

            var comments = from CachedData i in Cache.Values where i.Type == CachedDataType.Likes select i;
            return comments.ToArray();
        }

        public static CachedData[] FindAllPhotos()
        {
            if (Cache.Count == 0)
            {
                LoadCache();
            }

            var comments = from CachedData i in Cache.Values where i.Type == CachedDataType.Photos select i;
            return comments.ToArray();
        }

        public static CachedData[] FindAllStatuses()
        {
            if (Cache.Count == 0)
            {
                LoadCache();
            }

            var comments = from CachedData i in Cache.Values where i.Type == CachedDataType.Statuses select i;
            return comments.ToArray();
        }

        public static CachedData[] FilterCachedDataByUser(int userID, CachedDataType type)
        {
            var data = from CachedData i in Cache.Values where ((i.Type == type) && (i.UserID == userID)) select i;
            return data.ToArray();
        }

        public static CachedData[] FilterCachedDataByUser(string username, CachedDataType type)
        {
            var data = from CachedData i in Cache.Values where ((i.Type == type) && (i.Username == username)) select i;
            return data.ToArray();
        }

        public static void InstertIntoCache(CachedDataType type, CachedData data)
        {
            Cache.Add(type, data);
            List<byte[]> dataSegment = new List<byte[]>();
            dataSegment.Add(data.ToArray());
            Databases[type].AddRow(new EGNoSqlVirtualRow(new string[]{"MemCache"}, dataSegment));
        }

        public static UserRegisterResult RegisterUser(string username, string password, string ip, byte[] avatar, UserAccount.UserGender gender)
        {
            foreach (var v in Databases[CachedDataType.Users].FindCellData("Username"))
            {
                string uname = Encoding.ASCII.GetString(v);
                if (uname == username)
                    return UserRegisterResult.InvalidUsername;
            }
            if (password.Length < 6)
                return UserRegisterResult.InvalidPassword;

            //UserAccount acc = new UserAccount(username, password, Databases[CachedDataType.Users].RowCount + 1, gender, UserAccount.UserStatus.Offline, ip, avatar);
            List<byte[]> datas = new List<byte[]>();
            datas.Add(Encoding.ASCII.GetBytes(username));
            datas.Add(Encoding.ASCII.GetBytes(password));
            datas.Add(BitConverter.GetBytes(Databases[CachedDataType.Users].RowCount + 1));
            datas.Add(BitConverter.GetBytes((int)gender));
            datas.Add(BitConverter.GetBytes((int)UserAccount.UserStatus.Offline));
            datas.Add(Encoding.ASCII.GetBytes(ip));
            datas.Add(avatar);
            Databases[CachedDataType.Users].AddRow(new EGNoSqlVirtualRow(new string[] { "Username", "Password", "ID", "Gender", "Status", "IP", "Avatar" }, datas));
            return UserRegisterResult.Success;
        }

        public static UserLoginResult Login(string username, string password, string ip, UserAccount.UserStatus status)
        {
        //Working on this atm.
        }
    }
}