using System;
using System.Collections.Specialized;
using System.Text;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using System.Web;
using System.Web.Security;
using System.Collections.Generic;

namespace Professorweb.Providers.Store
{
    public class SimpleUser
    {
        public Guid UserKey = Guid.Empty;

        public string UserName = "";
        public string Password = "";
        public string PasswordSalt = "";

        public string Email = "";
        public DateTime CreationDate = DateTime.Now;
        public DateTime LastActivityDate = DateTime.MinValue;
        public DateTime LastLoginDate = DateTime.MinValue;
        public DateTime LastPasswordChangeDate = DateTime.MinValue;
        public string PasswordQuestion = "";
        public string PasswordAnswer = "";
        public string Comment;
    }

    public class SimpleRole
    {
        public string RoleName = "";
        public StringCollection AssignedUsers = new StringCollection();
    }

    public class UserStore
    {
        private string _FileName;
        private List<SimpleUser> _Users;
        private XmlSerializer _Serializer;

        #region "Singleton implementation"

        private static Dictionary<string, UserStore> _RegisteredStores;

        private UserStore(string fileName)
        {
            _FileName = fileName;
            _Users = new List<SimpleUser>();
            _Serializer = new XmlSerializer(typeof(List<SimpleUser>));

            LoadStore(_FileName);
        }

        public static UserStore GetStore(string fileName)
        {
            // Создать зарегистрированное хранилище, если оно еще не существует
            if (_RegisteredStores == null)
                _RegisteredStores = new Dictionary<string, UserStore>();

            if (!_RegisteredStores.ContainsKey(fileName))
            {
                _RegisteredStores.Add(fileName, new UserStore(fileName));
            }

            // Вернуть соответствующее хранилище no переданному имени файла
            return _RegisteredStores[fileName];
        }

        #endregion

        #region "Private Helper Methods"

        private void LoadStore(string fileName)
        {
            try
            {
                // Обратите внимание, что если файл не существует, в этот момент он игнорируется. 
                // При операции записи файл хранилища создается автоматически 
                // реализацией хранилища
                if (System.IO.File.Exists(fileName))
                {
                    using (XmlTextReader reader = new XmlTextReader(fileName))
                    {
                        _Users = (List<SimpleUser>)_Serializer.Deserialize(reader);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(
                    string.Format("Не удалось загрузить файл {0}", fileName), ex);
            }
        }

        private void SaveStore(string fileName)
        {
            try
            {
                if (System.IO.File.Exists(fileName))
                    System.IO.File.Delete(fileName);

                using (XmlTextWriter writer = new XmlTextWriter(fileName, Encoding.UTF8))
                {
                    _Serializer.Serialize(writer, _Users);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(
                    string.Format("Не удалось сохранить файл {0}", fileName), ex);
            }
        }

        #endregion

        public List<SimpleUser> Users
        {
            get { return _Users; }
        }

        public void Save()
        {
            SaveStore(_FileName);
        }

        public SimpleUser GetUserByName(string name)
        {
            return _Users.Find(
                user => string.Equals(name, user));
        }

        public SimpleUser GetUserByEmail(string email)
        {
            return _Users.Find(
                user => string.Equals(email, user.Email));
        }

        public SimpleUser GetUserByKey(Guid key)
        {
            return _Users.Find(
                user => user.UserKey.CompareTo(key) == 0);
        }
    }

    public class RoleStore
    {
        XmlSerializer _Serializer;
        private string _FileName;
        List<SimpleRole> _Roles;

        #region "Singleton Implementation"

        private static Dictionary<string, RoleStore> _RegisteredStores;

        public static RoleStore GetStore(string fileName)
        {
            // Создать зарегистрированные хранилища
            if (_RegisteredStores == null)
                _RegisteredStores = new Dictionary<string, RoleStore>();

            // Вернуть соответствующее хранилище
            if (!_RegisteredStores.ContainsKey(fileName))
            {
                _RegisteredStores.Add(fileName, new RoleStore(fileName));
            }

            return _RegisteredStores[fileName];
        }

        private RoleStore(string fileName)
        {
            _Roles = new List<SimpleRole>();
            _FileName = fileName;
            _Serializer = new XmlSerializer(typeof(List<SimpleRole>));

            LoadStore(_FileName);
        }

        #endregion

        #region "Private Helper Methods"

        private void LoadStore(string fileName)
        {
            try
            {
                // Хранилище создается автоматически при его сохранении
                if (System.IO.File.Exists(fileName))
                {
                    using (XmlTextReader reader = new XmlTextReader(fileName))
                    {
                        _Roles = (List<SimpleRole>)_Serializer.Deserialize(reader);
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception(string.Format(
                    "Не удалось загрузить файл {0}", fileName), ex);
            }
        }

        private void SaveStore(string fileName)
        {
            try
            {
                if (System.IO.File.Exists(fileName))
                    System.IO.File.Delete(fileName);

                using (XmlTextWriter writer = new XmlTextWriter(fileName, Encoding.UTF8))
                {
                    _Serializer.Serialize(writer, _Roles);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(string.Format(
                    "Не удалось сохранить файл {0}", fileName), ex);
            }
        }

        #endregion

        public List<SimpleRole> Roles
        {
            get { return _Roles; }
        }

        public void Save()
        {
            SaveStore(_FileName);
        }

        public List<SimpleRole> GetRolesForUser(string userName)
        {
            List<SimpleRole> Results = new List<SimpleRole>();
            foreach (SimpleRole r in Roles)
            {
                if (r.AssignedUsers.Contains(userName))
                    Results.Add(r);
            }
            return Results;
        }

        public string[] GetUsersInRole(string roleName)
        {
            SimpleRole Role = GetRole(roleName);
            if (Role != null)
            {
                string[] Results = new string[Role.AssignedUsers.Count];
                Role.AssignedUsers.CopyTo(Results, 0);
                return Results;
            }
            else
            {
                throw new Exception(string.Format("Роль с именем \"{0}\" не существует!", roleName));
            }
        }

        public SimpleRole GetRole(string roleName)
        {
            return Roles.Find(
                role => role.RoleName.Equals(
                    roleName, StringComparison.OrdinalIgnoreCase));
        }
    }
}