using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//----------------------------------------------------------------
//Module Name:  $safeprojectname$
//Purpose:      
//CopyRight:    Muchinfo
//History:
//----------------------------------------------------------------
//DateTime		2016/8/5 9:23:51
//Author       
//Description   Create
//----------------------------------------------------------------
using System.Windows;
using System.Windows.Input;
using GalaSoft.MvvmLight;
using GalaSoft.MvvmLight.Command;
using GalaSoft.MvvmLight.Ioc;
using Muchinfo.MTPClient.Data;
using Muchinfo.MTPClient.Data.Enums;
using Muchinfo.MTPClient.Data.Model.Account;
using Muchinfo.MTPClient.Data.Model.Delivery;
using Muchinfo.MTPClient.Infrastructure.Helpers;
using Muchinfo.MTPClient.Infrastructure.MessageBox;
using Muchinfo.MTPClient.Infrastructure.Utilities;
using Muchinfo.MTPClient.Infrastructure.Windows;
using Muchinfo.MTPClient.IService;
using Muchinfo.MTPClient.Resources;

namespace Muchinfo.MTPClient.Delivery.ViewModels
{
    /// <summary>
    /// 交割申报查询ViewModel
    /// </summary>
    public class DeliveryEntructViewModel : QueryPanelModelBase//QueryPanelPageModelBase<DeliveryEntrustOrder>
  {
      #region "私有字段/Private Data Members"
      protected IDeliveryService _deliveryService;
        #endregion "Private Data Members"

      #region "构造函数/Constructor/Initialization"
      public DeliveryEntructViewModel()
         {
            _deliveryService = SimpleIoc.Default.GetInstance<IDeliveryService>();
        }
        #endregion "Constructor/Initialization"

      #region "接口重写/Interface implementation Or override"
      /// <summary>
      /// 初始化注册消息
      /// </summary>RefreshContent
        public override void RegisterMessage()
        {
            EndTime = ApplicationParameter.ServerTimeNow;
            StartTime = ApplicationParameter.ServerTimeNow.AddDays(-30);
            RefreshCommand.Execute(null);
            MessengerHelper.DefaultUnregister<TradeAccount>(this, MessengerTokens.OrderNotify);
            MessengerHelper.DefaultRegister<TradeAccount>(this, MessengerTokens.OrderNotify, (e) =>
            {
                //接收通知时，防止时间设置错误，弹出错误提示
                EndTime = ApplicationParameter.ServerTimeNow;
                StartTime = ApplicationParameter.ServerTimeNow.AddDays(-30);
                RefreshCommand.Execute(null);
            });
        }

        public override void UnRegisterMessage()
        {
            MessengerHelper.DefaultUnregister(this);
        }
      /// <summary>
      /// 查询交收申报单
      /// </summary>
        public override void RefreshContent()
        {
            if (!Vailed())
            {
                return;
            }
            IsBusy = true;
            var queryList = new List<QueryCommonParam>();
            queryList.Add(new QueryCommonParam() { ParamKey = "userid", ParamValue = UserManager.CurrentTradeAccount.CustomerId + string.Empty });
            queryList.Add(new QueryCommonParam() { ParamKey = "starttime", ParamValue = StartTime.ToString() + string.Empty });
            queryList.Add(new QueryCommonParam() { ParamKey = "endtime", ParamValue = EndTime.ToString() + string.Empty });
            _deliveryService.QueryDeliveryDeclareByCapitalAccount(QueryStatement.QueryDeliverEntrustOrder, queryList, QuerySuccessCallBackNew, QueryErrorCallbackNew);

        }

        private void QuerySuccessCallBackNew(List<DeliveryEntrustOrder> orders)
        {
            UpdateItemSource(orders);
            IsBusy = false;
        }
        private void QueryErrorCallbackNew(ErrorEntity error)
        {
            IsBusy = false;
        }
        #endregion "Interface implementation Or override"

      #region "Public Properties To Get/Set "

        #region 开始时间
        private DateTime startTime;

        /// <summary>
        /// 开始时间
        /// </summary>
        public DateTime StartTime
        {
            get { return startTime; }
            set { Set(() => StartTime, ref startTime, value); }
        }
        #endregion

        #region 结束时间
        private DateTime _endTime;

        /// <summary>
        /// 结束时间
        /// </summary>
        public DateTime EndTime
        {
            get { return _endTime; }
            set { Set(() => EndTime, ref _endTime, value); }
        }
        #endregion

        #region 未审核ListSource
        private List<DeliveryEntrustOrder> _unAduitOrders;

        /// <summary>
        /// 未审核ListSource
        /// </summary>
        public List<DeliveryEntrustOrder> UnAduitOrders
        {
            get { return _unAduitOrders; }
            set { Set(() => UnAduitOrders, ref _unAduitOrders, value); }
        }
        #endregion

        #region 审核不通过的ListSource
        private List<DeliveryEntrustOrder> _refuseOrders;

        /// <summary>
        /// 审核不通过的ListSource
        /// </summary>
        public List<DeliveryEntrustOrder> RefuseOrders
        {
            get { return _refuseOrders; }
            set { Set(() => RefuseOrders, ref _refuseOrders, value); }
        }
        #endregion

        #region 所有单据ListSource【“待审核”、“未通过”、“已通过”、“已配对”】
        private List<DeliveryEntrustOrder> _allOrders;

        /// <summary>
        /// 所有单据ListSource
        /// </summary>
        public List<DeliveryEntrustOrder> AllOrders
        {
            get { return _allOrders; }
            set { Set(() => AllOrders, ref _allOrders, value); }
        }
        #endregion

        #region 选择当前行【实体】
        private DeliveryEntrustOrder _selectEntrustOrder;

        /// <summary>
        /// 选择 行
        /// </summary>
        public DeliveryEntrustOrder SelectEntrustOrder
        {
            get { return _selectEntrustOrder; }
            set { Set(() => SelectEntrustOrder, ref _selectEntrustOrder, value); }
        }

        #endregion 
        #endregion "Public Properties To Get/Set "

      #region "Public Commands"
        #region 交割申报下单命令Command
        private RelayCommand _deliveryCommand;

        /// <summary>
        /// Gets the DeliveryCommand.
        /// </summary>
        public RelayCommand DeliveryCommand
        {
            get
            {
                return _deliveryCommand
                    ?? (_deliveryCommand = new RelayCommand(
                    () =>
                    {
                        MessengerHelper.DefaultSend(UserManager.CurrentTradeAccount, MessengerTokens.DeliveryDeclare);
                    }));
            }
        }
        #endregion

        #region 重置查询时间命令Command
        private RelayCommand _resetCommand;

        /// <summary>
        /// Gets the ResetCommand.
        /// </summary>
        public RelayCommand ResetCommand
        {
            get
            {
                return _resetCommand
                    ?? (_resetCommand = new RelayCommand(
                    () =>
                    {
                        EndTime = ApplicationParameter.ServerTimeNow;
                        StartTime = ApplicationParameter.ServerTimeNow.AddDays(-30);
                    }));
            }
        }
        #endregion

        #region 撤销命令Command
        public ICommand CancelCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    
                    if (SelectEntrustOrder != null)
                    {
                        
                       
                    }

                });
            }
        }
        #endregion

        #region 撤销或配对命令Command

        private RelayCommand _cancelOrMatchCommand;

        /// <summary>
        /// Gets the CancelOrMatchCommand.
        /// </summary>
        public RelayCommand CancelOrMatchCommand
        {
            get
            {
                return _cancelOrMatchCommand
                    ?? (_cancelOrMatchCommand = new RelayCommand(
                    () =>
                    {
                        switch (SelectEntrustOrder.OrderStatus)
                        {

                            default:
                                break;

                        }
                    }));
            }
        }

        /// <summary>
        /// 撤销命令
        /// </summary>
        public RelayCommand CancelCammand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    MessageBoxHelper.ShowInfo("功能开发中,敬请期待", Muchinfo.MTPClient.Resources.Client_Resource.Models_Tips, true);
                    return;
                    //if (SelectEntrustOrder == null) return;
                    //PostCancelOrder();
                }, () => CanCancelOrderDetial());
            }
        }
        /// <summary>
        /// 撤销操作Event
        /// </summary>
        private void PostCancelOrder()
        {
            if (SelectEntrustOrder != null)
            {
                //var orderBuild = BuildEntrustOrder();
                //long orderNumber = orderBuild.RelateOrderID;
                ////var boxResult = MessageBoxHelper.ShowQuestion(Muchinfo.MTPClient.Resources.Client_Resource.Models_MakesureCancel + orderNumber + Muchinfo.MTPClient.Resources.Client_Resource.Models_Bill,
                ////    Muchinfo.MTPClient.Resources.Client_Resource.Models_CancelBillTips);
                //var boxResult = MessageBoxHelper.ShowQuestion(Muchinfo.MTPClient.Resources.Client_Resource.Models_MakesureToCancel,
                //   Muchinfo.MTPClient.Resources.Client_Resource.Models_CancelBillTips);
                //if (boxResult == MessageBoxResult.Yes)
                //{
                //    IsBusy = true;

                //    _deliveryService.DeliveryApplyOrder(orderBuild, EntrurstSuccessCallBack, EntrurstErrorCallBack);


                //}

            }
        }
        /// <summary>
        /// 是否可撤单
        /// </summary>
        /// <returns></returns>
        public bool CanCancelOrderDetial()
        {
            var result = false;
            return result;

        }
        #endregion

        #region 查看详情
        private RelayCommand<DeliveryEntrustOrder> _seeMoreDetailCommand;

        /// <summary>
        /// 查看详情
        /// </summary>
        public RelayCommand<DeliveryEntrustOrder> SeeMoreDetailCommand
        {
            get
            {
                return _seeMoreDetailCommand
                    ?? (_seeMoreDetailCommand = new RelayCommand<DeliveryEntrustOrder>(
                    p =>
                    {
                        MessengerHelper.DefaultSend(SelectEntrustOrder, MessengerTokens.DeliveryEntructOrderDetail);
                    }));
            }
        }
        #endregion

        #region 撤销命令
        private RelayCommand _cancelsCommand;

        /// <summary>
        /// 撤销命令
        /// </summary>
        public RelayCommand CancelsCommand
        {
            get
            {
                return _cancelsCommand
                    ?? (_cancelsCommand = new RelayCommand(
                    () =>
                    {
                         PostCancelOrder();
                    }));
            }
        } 
        #endregion

        #region 点选仓单命令
        private RelayCommand _matchCommand;

        /// <summary>
        /// 点选仓单命令
        /// </summary>
        public RelayCommand MatchCommand
        {
            get
            {
                return _matchCommand
                    ?? (_matchCommand = new RelayCommand(
                    () =>
                    {
                        MessageBoxHelper.ShowInfo("功能开发中,敬请期待", Muchinfo.MTPClient.Resources.Client_Resource.Models_Tips, true);
                        if (SelectEntrustOrder.accountid == 0)
                        {
                            SelectEntrustOrder.accountid = UserManager.CurrentTradeAccount.FundsAccountId;
                        }
                        //MessengerHelper.DefaultSend(SelectEntrustOrder, MessengerTokens.DeliveryMatchDeclare);
                    }));
            }
        } 
        #endregion
        #endregion "Public Commands"

      #region "Private Methods"

        #region 创建下单委托对象
        /// <summary>
        /// 创建下单委托对象
        /// </summary>
        /// <returns>下单委托对象</returns> 
        private DeliveryOrderReqModel BuildEntrustOrder()
        {
            //string loginCode, string tradeCode, long orderId, long entrustId, decimal quantity, string goodsCode
            //var entrustId = CurrentLimitOrder.EntrustId;
            var newOrder = new DeliveryOrderReqModel()
            {

            };

            //if (UserManager.CurrentTradeAccount.FundsAccounts.Any() &&
            //    UserManager.CurrentTradeAccount.FundsAccounts[0] != null)
            //{
            //    newOrder.AccountId = UserManager.CurrentTradeAccount.FundsAccounts[0].AccountId;
            //}
            //else
            //{
            //    newOrder.AccountId = UserManager.CurrentTradeAccount.AccountId;
            //}



            return newOrder;
        }
        #endregion

        /// 撤销成功返回
        /// </summary>
        /// <param name="order"></param>
        private void EntrurstSuccessCallBack(DeliveryOrderRspModel order)
        {
            IsBusy = false;
            Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {

                MessageBoxHelper.ShowSuccess(Muchinfo.MTPClient.Resources.Client_Resource.Account_CancelSuccess,
                    Client_Resource.Cancel_MessageBox_Title);
                //MessageBoxHelper.ShowSuccess(Client_Resource.Order_Success_Result,
                //    Client_Resource.Cancel_MessageBox_Title);

                //if (_openWindow != null)
                //{
                //    _openWindow.Close();
                //    this.Cleanup();
                //}


            }));
            MessengerHelper.DefaultSend(UserManager.CurrentTradeAccount, MessengerTokens.OrderNoticeToken);
        }

        /// <summary>
        /// 撤销失败返回
        /// </summary>
        /// <param name="errorEntity"></param>
        private void EntrurstErrorCallBack(ErrorEntity errorEntity)
        {
            Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                ErrorManager.ShowReturnError(errorEntity, Client_Resource.UI2014_Tips, true);

                IsBusy = false;
            }));

        }

        /// <summary>
        /// 查询成功返回
        /// </summary>
        /// <param name="orders"></param>
        protected void MarketOrderSuccess(List<DeliveryEntrustOrder> orders)
        {
            UpdateItemSource(orders);
            IsBusy = false;
        }

        /// <summary>
        /// 查询失败返回
        /// </summary>
        /// <param name="errorEntity"></param>
        public override void QueryErrorCallback(ErrorEntity errorEntity)
        {
            IsBusy = false;
            var errorMsg = string.Format("{0}:{1}", errorEntity.RequestFunc, ErrorManager.FormatErrorMsg(errorEntity)); //错误信息显示到状态
            MessengerHelper.DefaultSend(errorMsg, MessengerTokens.ErrorMessage);
            // base.QueryErrorCallback();
        }

        /// <summary>
        /// 更新数据源
        /// </summary>
        /// <param name="orders"></param>
        private void UpdateItemSource(List<DeliveryEntrustOrder> orders)
        {
            if (orders != null)
            {
                foreach (var orderitem in orders)
                {
                    if (orderitem.PPriceMode == 1)
                    {
                        orderitem.IsVisibility_RelationModeP = Visibility.Visible;
                    }
                    else
                    {
                        orderitem.IsVisibility_RelationModeP = Visibility.Collapsed;
                    }
                    if (orderitem.P2PriceMode == 1)
                    {
                        orderitem.IsVisibility_RelationModeP2 = Visibility.Visible;
                    }
                    else
                    {
                        orderitem.IsVisibility_RelationModeP2 = Visibility.Collapsed;
                    }
                }
                AllOrders = orders.OrderByDescending(x => x.OrderTime).ToList();//所有单据
            }
        }
        #endregion "Private Methods"

      #region "Other Methods like Validated"


        /// <summary>
        /// 数据验证
        /// </summary>
        /// <returns></returns>
        private bool Vailed()
        {
            if (StartTime > EndTime)
            {
                MessageBoxHelper.ShowInfo(Muchinfo.MTPClient.Resources.Client_Resource.DateTimeVaided_StartEnd, Muchinfo.MTPClient.Resources.Client_Resource.Models_Tips, true);
                return false;
            }
            else if ((EndTime - StartTime).Days > 30)
            {
                MessageBoxHelper.ShowInfo(Muchinfo.MTPClient.Resources.Client_Resource.DateTimeVaided_Over30days, Muchinfo.MTPClient.Resources.Client_Resource.Models_Tips, true);
                return false;
            }
            return true;
        }
        #endregion "Other Methods like Validated"

    }
}