/*
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.Text;
using System.Collections.Generic;
using System.Linq;

using StockholmLibrary.Net;
using StockholmLibrary.Game.Sessions;
using StockholmLibrary.Game.Packets.Server;
using StockholmLibrary.Game.Packets.Client;

using StockholmLibrary.Data;

namespace StockholmLibrary.Game.Handlers.Specific
{
    //------------------------------------
    public class SessionUserHandler
    {
        Session _session;

        //**********************************************
        public SessionUserHandler(Session session)
        {
            _session = session;

            SendInitialLoginInfo();

            Stockholm.Get().PacketManager.RegisterPeerHandler(_session.Peer, Packets.Client.EClientPacket.GET_INFO, new PacketRoutingInfo.ProcessPacketDelegate(HandleGetInfo), true);
            Stockholm.Get().PacketManager.RegisterPeerHandler(_session.Peer, Packets.Client.EClientPacket.GET_CREDITS, new PacketRoutingInfo.ProcessPacketDelegate(HandleGetCredits), true);
            Stockholm.Get().PacketManager.RegisterPeerHandler(_session.Peer, Packets.Client.EClientPacket.SCR_GET_USER_INFO, new PacketRoutingInfo.ProcessPacketDelegate(HandleGetSubscriptionInfo), true);
            Stockholm.Get().PacketManager.RegisterPeerHandler(_session.Peer, Packets.Client.EClientPacket.GET_AVAILABLE_BADGES, new PacketRoutingInfo.ProcessPacketDelegate(HandleGetAvailableBadges), true);
            Stockholm.Get().PacketManager.RegisterPeerHandler(_session.Peer, Packets.Client.EClientPacket.UPDATE, new PacketRoutingInfo.ProcessPacketDelegate(HandleUserUpdate), true);
            Stockholm.Get().PacketManager.RegisterPeerHandler(_session.Peer, Packets.Client.EClientPacket.UPDATE_ACCOUNT, new PacketRoutingInfo.ProcessPacketDelegate(HandleAccountUpdate), true);
            Stockholm.Get().PacketManager.RegisterPeerHandler(_session.Peer, Packets.Client.EClientPacket.REDEEM_VOUCHER, new PacketRoutingInfo.ProcessPacketDelegate(HandleRedeemVoucher), true);
        }

        //**********************************************
        private void SendInitialLoginInfo()
        {
            // Rights list
            FuseRightsPacket packet = new FuseRightsPacket(Stockholm.Get().GameManager.RoleManager.GetRightsList(_session.User.RoleID));
            _session.Peer.EnqueuePacket(packet);

            // Login Ok
            _session.Peer.EnqueuePacket(new LoginOkPacket());

            // Allowed Sets
            _session.Peer.EnqueuePacket(new ClientAllowedSetsPacket());
        }

        //**********************************************
        private void HandleGetInfo(ClientPacket packet)
        {
            UserObjectPacket userObjectPacket = new UserObjectPacket(_session.User);
            _session.Peer.EnqueuePacket(userObjectPacket);
        }

        //**********************************************
        private void HandleGetCredits(ClientPacket packet)
        {
            WalletBalancePacket walletBalancePacket = new WalletBalancePacket(_session.User.Credits);
            _session.Peer.EnqueuePacket(walletBalancePacket);
        }

        //**********************************************
        private void HandleGetSubscriptionInfo(ClientPacket packet)
        {
            GetSubscriptionInfoPacket getSubscriptionInfoPacket = new GetSubscriptionInfoPacket();
            getSubscriptionInfoPacket.Deserialise(packet);

            if (getSubscriptionInfoPacket.SubscriptionType == "club_habbo")
            {
                SubscriptionInfoPacket subscriptionInfoPacket = new SubscriptionInfoPacket(getSubscriptionInfoPacket.SubscriptionType, _session.User);
                _session.Peer.EnqueuePacket(subscriptionInfoPacket);
            }
        }

        //**********************************************
        private void HandleGetAvailableBadges(ClientPacket packet)
        {
            List<string> badgeList = Stockholm.Get().GameManager.RoleManager.GetBadgeList(_session.User.RoleID);
            BadgeListPacket badgeListPacket = new BadgeListPacket(badgeList, _session.User.CurrentBadge);
            _session.Peer.EnqueuePacket(badgeListPacket);
        }

        private void HandleUserUpdate(ClientPacket packet)
        {
            UserPropertiesPacket userPacket = new UserPropertiesPacket();
            userPacket.Deserialise(packet);

            // Get newest user info from database
            StockholmDbDataContext db = Stockholm.Get().Database;
            User user = (from p in db.Users where p.UserID == _session.User.UserID select p).Single();

            // Figure changed?
            if (userPacket.Properties[Util.EUserProperty.Figure] != null)
            {
                string figure = userPacket.Properties[Util.EUserProperty.Figure];
                if (Stockholm.Get().GameManager.DataValidator.ValidateUserFigure(figure))
                {
                    user.Figure = figure;
                }
            }

            // Sex changed?
            if (userPacket.Properties[Util.EUserProperty.Sex] != null)
            {
                user.Sex = (userPacket.Properties[Util.EUserProperty.Sex] == "F") ? "F" : "M";
            }

            // Motto changed?
            if (userPacket.Properties[Util.EUserProperty.Motto] != null)
            {
                user.Motto = userPacket.Properties[Util.EUserProperty.Motto];
            }

            // Write changes to database and Session
            db.SubmitChanges();
            _session.User = user;

            // Re-send user info
            _session.Peer.EnqueuePacket(new UserObjectPacket(_session.User));
        }

        private void HandleAccountUpdate(ClientPacket packet)
        {
            UpdateAccountPacket updatePacket = new UpdateAccountPacket();
            updatePacket.Deserialise(packet);

            // If all works out, then there is no error
            AccountUpdatedPacket.ErrorCode error = AccountUpdatedPacket.ErrorCode.Ok;

            // Verify password & dob
            if (updatePacket.CurrentPassword != _session.User.Password)
            {
                error = AccountUpdatedPacket.ErrorCode.NegativePasswordMatch;
            }
            else if (updatePacket.DateOfBirth != _session.User.Dob)
            {
                error = AccountUpdatedPacket.ErrorCode.NegativeDobMatch;
            }
            else
            {
                StockholmDbDataContext db = Stockholm.Get().Database;
                User user = (from p in db.Users where p.UserID == _session.User.UserID select p).Single();

                // What has changed? Password or email?
                if (updatePacket.NewPassword != null)
                {
                    // Valid new password?
                    if (Stockholm.Get().GameManager.DataValidator.ValidateUserPassword(_session.User.Username, updatePacket.NewPassword))
                    {
                        user.Password = updatePacket.NewPassword;
                    }
                }
                else if (updatePacket.NewEmail != null)
                {
                    user.Email = updatePacket.NewEmail;
                }

                // Update changes to database and Session
                db.SubmitChanges();
                _session.User = user;
            }

            // Send the result message
            _session.Peer.EnqueuePacket(new AccountUpdatedPacket(error));
        }

        private void HandleRedeemVoucher(ClientPacket packet)
        {
            RedeemVoucherPacket redeemPacket = new RedeemVoucherPacket();
            redeemPacket.Deserialise(packet);

            StockholmDbDataContext db = Stockholm.Get().Database;
            var voucherQuery = from p in db.Vouchers where p.Code == redeemPacket.VoucherCode select p;
            if (voucherQuery.Count() == 0)
            {
                var error = VoucherRedeemErrorPacket.Error.NotFound;
                _session.Peer.EnqueuePacket(new VoucherRedeemErrorPacket(error));
            }
            else
            {
                Voucher voucher = voucherQuery.Single();

                // Process the payload
                if (voucher.PayloadType == "credits")
                {
                    int amount;
                    if (int.TryParse(voucher.Payload, out amount))
                    {
                        User user = (from p in db.Users where p.UserID == _session.User.UserID select p).Single();
                        user.Credits += amount;

                        // Refresh wallet balance
                        _session.User = user;
                        _session.Peer.EnqueuePacket(new WalletBalancePacket(_session.User.Credits));
                    }
                }

                // Delete the voucher and submit other changes
                db.Vouchers.DeleteOnSubmit(voucher);
                db.SubmitChanges();

                // Voucher redeemed successfully!
                _session.Peer.EnqueuePacket(new ServerPacket(EServerPacket.REDEEM_VOUCHER_OK));
            }
        }
    }
}