/*
Thor Server 2.0 Project - Codenamed "Stockholm"
Copyright 2008 - 2009 Joe Hegarty


This file is part of The Thor Server 2.0 Project - Codenamed "Stockholm".

The Thor Server 2.0 Project - Codenamed "Stockholm" is free software: you can 
redistribute it and/or modify it under the terms of the Microsoft Public License

The Thor Server Project is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
Microsoft Public License for more details.

You should have received a copy of the Microsoft Public License
along with The Thor Server Project.  If not, see 
http://www.opensource.org/licenses/ms-pl.html
*/

using System;
using System.Collections.Generic;
using System.Linq;

using StockholmLibrary.Data;
using StockholmLibrary.Util;

namespace StockholmLibrary.Game.Sessions
{
    //------------------------------------
    public class RoleManager
    {
        //------------------------------------
        private class Role
        {
            int _roleId;
            int? _inheritedRole;
            string _name;
            List<string> _roleAccess = new List<string>();
            List<string> _roleBadges = new List<string>();

            //**********************************************
            public List<string> AccessList
            {
                get
                {
                    return _roleAccess;
                }

            }

            //**********************************************
            public List<string> BadgeList
            {
                get
                {
                    return _roleBadges;
                }
            }

            //**********************************************
            public string Name
            {
                get
                {
                    return _name;
                }
            }

            //**********************************************
            public int RoleID
            {
                get
                {
                    return _roleId;
                }
            }

            //**********************************************
            public int? InheritedRole
            {
                get
                {
                    return _inheritedRole;
                }
            }

            //**********************************************
            public Role(int roleId, string name, int? inheritedRole)
            {
                _roleId = roleId;
                _name = name;
                _inheritedRole = inheritedRole;
            }

            //**********************************************
            public bool HasAccess(string access)
            {
                return _roleAccess.Contains(access);
            }

            //**********************************************
            public bool HasBadge(string badge)
            {
                return _roleBadges.Contains(badge);
            }

            //**********************************************
            public void AddAccess(string access)
            {
                _roleAccess.Add(access);
            }

            //**********************************************
            public void AddBadge(string badge)
            {
                _roleBadges.Add(badge);
            }
        }

        Dictionary<int, Role> _roleCache = new Dictionary<int, Role>();
        object _roleLock = new object();
        
        //**********************************************
        public RoleManager()
        {
            RefreshRoles();
        }

        //**********************************************
        public void RefreshRoles()
        {
            StockholmDbDataContext db = Stockholm.Get().Database;
            var roleQuery = from p in db.Roles select p.RoleID;

            foreach (var roleId in roleQuery)
            {
                ProcessRole(roleId);
            }

            Logging.LogEvent("RoleManager", "Successfully cached " + _roleCache.Count + " roles", Logging.ELogLevel.INFO);
        }

        //**********************************************
        private void ProcessRole(int roleId)
        {
            StockholmDbDataContext db = Stockholm.Get().Database;

            var roleQuery = from p in db.Roles where p.RoleID == roleId select p;
            var roleResult = roleQuery.Single();

            Role role = new Role(roleId, roleResult.RoleName, roleResult.InheritedRole);


            var accessQuery = from p in db.RoleAccesses where p.RoleID == roleId select p;
            foreach (var access in accessQuery)
            {
                role.AddAccess(access.AccessName);
            }

            var badgeQuery = from p in db.Badges where p.RoleID == roleId select p;
            foreach (var badge in badgeQuery)
            {
                role.AddBadge(badge.BadgeName);
            }

            _roleCache.Add(role.RoleID, role);
        }

        //**********************************************
        public bool HasAccess(int roleId, string access)
        {
            lock (_roleLock)
            {
                if (_roleCache.ContainsKey(roleId))
                {
                    Role role = _roleCache[roleId];
                    if (role.HasAccess(access)) return true;

                    while (role.InheritedRole != null)
                    {
                        int tempid = (int)role.InheritedRole;
                        if (_roleCache.ContainsKey(tempid))
                        {
                            role = _roleCache[tempid];
                            if (role.HasAccess(access)) return true;
                        }
                    }
                }
            }

            return false;
        }

        //**********************************************
        public bool HasBadge(int roleId, string badge)
        {
            lock (_roleLock)
            {
                if (_roleCache.ContainsKey(roleId))
                {
                    Role role = _roleCache[roleId];
                    if (role.HasBadge(badge)) return true;

                    while (role.InheritedRole != null)
                    {
                        int tempid = (int)role.InheritedRole;
                        if (_roleCache.ContainsKey(tempid))
                        {
                            role = _roleCache[tempid];
                            if (role.HasBadge(badge)) return true;
                        }
                    }
                }
            }

            return false;
        }

        //**********************************************
        public List<string> GetRightsList(int roleId)
        {
            List<string> accessList = new List<string>();

            lock (_roleLock)
            {
                if (_roleCache.ContainsKey(roleId))
                {
                    Role role = _roleCache[roleId];

                    accessList.AddRange(role.AccessList);

                    while (role.InheritedRole != null)
                    {
                        int tempid = (int)role.InheritedRole;
                        if (_roleCache.ContainsKey(tempid))
                        {
                            role = _roleCache[tempid];
                            accessList.AddRange(role.AccessList);
                        }
                    }
                }

            }

            return accessList;
        }

        //**********************************************
        public List<string> GetBadgeList(int roleId)
        {
            List<string> badgeList = new List<string>();

            lock (_roleLock)
            {
                if (_roleCache.ContainsKey(roleId))
                {
                    Role role = _roleCache[roleId];

                    badgeList.AddRange(role.BadgeList);

                    while (role.InheritedRole != null)
                    {
                        int tempid = (int)role.InheritedRole;
                        if (_roleCache.ContainsKey(tempid))
                        {
                            role = _roleCache[tempid];
                            badgeList.AddRange(role.BadgeList);
                        }
                    }
                }

            }

            return badgeList;
        }
    }
}