using System;
using System.Collections.Generic;
using System.Configuration;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using FutTrader2000.Messages;
using GalaSoft.MvvmLight.Messaging;
using log4net;
using UltimateTeam.Toolkit;
using UltimateTeam.Toolkit.Exceptions;
using UltimateTeam.Toolkit.Factories;
using UltimateTeam.Toolkit.Models;
using UltimateTeam.Toolkit.Parameters;

namespace FutTrader2000.Models
{
    public class FutClientWrapper : IFutClientWrapper
    {
        private static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

        private readonly FutClient _futClient;
        private DateTime _lastException;

        public FutClientWrapper()
        {
            _futClient = new FutClient();
            ClientReady = false;
        }

        private DateTime LastException
        {
            get { return _lastException; }
            set { _lastException = value; }
        }


        public async Task<LoginResponse> LoginAsync(LoginDetails loginDetails)
        {
            var response = await Invoke(f => f.LoginAsync(loginDetails), loginDetails);
            ClientReady = true;
            Messenger.Default.Send(new LoggedInMessage());
            return response;
        }

        public async Task<AuctionResponse> SearchAsync(SearchParameters searchParameters)
        {
            return await Invoke(f => f.SearchAsync(searchParameters), searchParameters);
        }

        public async Task<AuctionResponse> PlaceBidAsync(AuctionInfo auctionInfo, uint bidAmount = 0)
        {
            return await Invoke(f => f.PlaceBidAsync(auctionInfo, bidAmount), auctionInfo);
        }

        public async Task<Item> GetItemAsync(long resourceId)
        {
            return await Invoke(f => f.GetItemAsync(resourceId), resourceId);
        }

        public async Task<Item> GetItemAsync(AuctionInfo auctionInfo)
        {
            return await Invoke(f => f.GetItemAsync(auctionInfo), auctionInfo);
        }

        public async Task<byte[]> GetPlayerImageAsync(AuctionInfo auctionInfo)
        {
            return await Invoke(f => f.GetPlayerImageAsync(auctionInfo), auctionInfo);
        }

        public async Task<AuctionResponse> GetTradeStatusAsync(IEnumerable<long> tradeIds)
        {
            return await Invoke(f => f.GetTradeStatusAsync(tradeIds), tradeIds);
        }

        public async Task<CreditsResponse> GetCreditsAsync()
        {
            return await Invoke(f => f.GetCreditsAsync());
        }

        public async Task<PileSizeResponse> GetPileSizeAsync()
        {
            return await Invoke(f => f.GetPileSizeAsync());
        }

        public async Task<AuctionResponse> GetTradePileAsync()
        {
            return await Invoke(f => f.GetTradePileAsync());
        }

        public async Task<WatchlistResponse> GetWatchlistAsync()
        {
            return await Invoke(f => f.GetWatchlistAsync());
        }

        public async Task<PurchasedItemsResponse> GetPurchasedItemsAsync()
        {
            return await Invoke(f => f.GetPurchasedItemsAsync());
        }

        public async Task<ListAuctionResponse> ListAuctionAsync(AuctionDetails auctionDetails)
        {
            return await Invoke(f => f.ListAuctionAsync(auctionDetails), auctionDetails);
        }

        public Task RemoveFromWatchlistAsync(AuctionInfo auctionInfo)
        {
            return Invoke(f => f.RemoveFromWatchlistAsync(auctionInfo), auctionInfo);
        }

        public Task RemoveFromWatchlistAsync(IEnumerable<AuctionInfo> auctionInfo)
        {
            return Invoke(f => f.RemoveFromWatchlistAsync(auctionInfo), auctionInfo);
        }

        public Task RemoveFromTradePileAsync(AuctionInfo auctionInfo)
        {
            return Invoke(f => f.RemoveFromTradePileAsync(auctionInfo), auctionInfo);
        }

        public async Task<SendItemToTradePileResponse> SendItemToTradePileAsync(ItemData itemData)
        {
            return await Invoke(f => f.SendItemToTradePileAsync(itemData), itemData);
        }

        public async Task<QuickSellResponse> QuickSellItemAsync(long itemId)
        {
            return await Invoke(f => f.QuickSellItemAsync(itemId), itemId);
        }

        public FutRequestFactories RequestFactories { get; private set; }

        public bool ClientReady { get; set; }

        private async void Login()
        {
            try
            {
                string email = ConfigurationManager.AppSettings["Email"];
                string password = ConfigurationManager.AppSettings["Password"];
                string secretAnswer = ConfigurationManager.AppSettings["SecretQuestion"];
                string configValue = ConfigurationManager.AppSettings["Platform"];
                var platform = (Platform) Enum.Parse(typeof (Platform), configValue);
                await _futClient.LoginAsync(new LoginDetails(email, password, secretAnswer, platform));
                Messenger.Default.Send(new ConsoleMessage(ConsoleMessageType.General, "Logged in"));
                ClientReady = true;
                Messenger.Default.Send(new LoggedInMessage());
            }
            catch (Exception e)
            {
                Log.Error("Error logging in", e);
            }
        }

        public TResult Invoke<TResult>(Func<FutClient, TResult> func, object requestDetails = null,
            [CallerMemberName] string exceptionMessage = null)
        {
            try
            {
                if (LastException + new TimeSpan(0, 0, 30) < DateTime.Now)
                {
                    TResult result = func(_futClient);
                    return result;
                }
            }
            catch (ExpiredSessionException e)
            {
                //Relog
                string message = "Exception in FutclientWrapper" + exceptionMessage + GetRequestDetails(requestDetails);
                Messenger.Default.Send(new ConsoleMessage(ConsoleMessageType.Error, message, e));
                Log.Error(message, e);
                ClientReady = false;
                if (LastException + new TimeSpan(0, 0, 30) < DateTime.Now)
                {
                    LastException = DateTime.Now;
                    Login();
                }
            }
            catch (ServiceUnavailableException e)
            {
                //sleep
                string message = "Exception in FutclientWrapper" + exceptionMessage + GetRequestDetails(requestDetails);
                Messenger.Default.Send(new ConsoleMessage(ConsoleMessageType.Error, message, e));
                ClientReady = false;
                Log.Error(message, e);
            }
            catch (Exception e)
            {
                string message = "Exception in FutclientWrapper" + exceptionMessage + GetRequestDetails(requestDetails);
                Log.Error(message, e);
                ClientReady = false;
                Messenger.Default.Send(new ConsoleMessage(ConsoleMessageType.Error, message, e));
            }
            return default(TResult);
        }

        private string GetRequestDetails(object request)
        {
            if (request == null)
            {
                return string.Empty;
            }

            Type requestType = request.GetType();

            string msg = requestType.FullName;
            foreach (PropertyInfo propInfo in requestType.GetProperties())
            {
                object val = propInfo.GetValue(request);
                msg += string.Format("{0}{1}: {2}", Environment.NewLine, propInfo.Name, val);
            }
            return msg;
        }
    }
}