void OnItemClicked(MessageEventArgs args)
 {
     int itemID = args.GetMessage<int>("ItemID");
     ItemData itemData = DataManager.Instance.GetItemDataSet().GetItemData(itemID);
     args.AddMessage ("Message", itemData.description);
     EventManager.Instance.PostEvent (UIEvent.OnMessageSet, args);
 }

    /*UI CALLBACK*/
    public void EnterBattle(int battleType)
    {
        MessageEventArgs arg = new MessageEventArgs();
        arg.AddMessage("WindowID", UIWindowID.BattleWindow);
        EventManager.Instance.PostEvent(UIEvent.OpenUIWindow, arg);

        MessageEventArgs args = new MessageEventArgs ();
        args.AddMessage("BattleType",battleType);
        if(battleType == 0)
        {
            args.AddMessage("Man",true);
            args.AddMessage("Girl",true);
            args.AddMessage("Enemy",new int[3]{101,102,103});
        }
        else if(battleType == 1)
        {
            args.AddMessage("Man",true);
            args.AddMessage("Girl",true);
            args.AddMessage("Enemy",new int[1]{104});
        }
        else
        {
            args.AddMessage("Man",true);
            args.AddMessage("Enemy",new int[1]{105});
        }
        EventManager.Instance.PostEvent (BattleEvent.OnBattleEnter, args);
    }

 private void OnMessageEvent(string messagetype, string message)
 {
     MessageEventArgs mea = new MessageEventArgs();
     mea.messagetype = messagetype;
     mea.message = message;
     OnMessage.BeginInvoke(this, mea, null, null);
 }

 void OnCommandShowUp(MessageEventArgs args)
 {
     commandPanel.SetActive(true);
     subCommandPanel.SetActive (true);
     commandPanel.GetComponent<CommandPanelUIEvent>().SetButtonActive();
     EventManager.Instance.PostEvent(UIEvent.OnMessageHide);
 }

 public bool changeResourceStock(object sender, MessageEventArgs e, TypeResource resourceType, int value)
 {
     //Debug.Log("Changing resource stock : " + resourceType.ToString() + " - " + value.ToString());
     char islandNumber = ((string)e.message.Split('@').GetValue(1))[1];
     if (!gameObject.name.Contains(islandNumber))
     {
         //Island not concerned
         return false;
     }
     //Debug.Log("Stock update : " + e.message);
     Resource resource = this.getResource(resourceType);
     bool result = false;
     if (resource != null)
     {
         result = resource.changeStock(value);
     }
     else
     {
         if (value >= 0)
         {
             this.addResource(resourceType, value);
             result = true;
         }
         else
         {
             return false;
         }
     }
     //The board shouldn't notice the network of an gloabl stock update
     if(this.ChangeResourceStockEvent != null) // && result)
     {
         this.ChangeResourceStockEvent(this, new ChangeResourceStockEventArgs { resourceType = resourceType, stock = value }); // resource.Stock });
     }
     return result;
 }

    void onMessageReceived(object sender, MessageEventArgs e)
    {
        try
        {
            var json = JSON.Parse(e.Data.Substring(2));

            string tag = json.AsArray[0];
            JSONNode objJson = json.AsArray[1];

            switch (tag) {
                // from web client
                case "obj" :
                    int objType = objJson["id"].AsInt;
                    int position = objJson["pos"].AsInt;
                    resources.Add(new ResourceObject(objType, position));
                    break;
                // from unity, so this would be other unity clients.  May handle in future
                case "pos" :
                    break;
                case "score":
                    break;
                case "invW":
                    break;
                case "invR":
                    break;
                case "invG":
                    break;
                default :
                    break;
            }

        }

        catch (System.Exception error) {/* Debug.log(error.StackTrace) */ }
    }

    void OpenUIWindow(MessageEventArgs args)
    {
        UIWindowID windowID = args.GetMessage<UIWindowID>("WindowID");

        if(windowStack.Count > 0)
        {
            GameObject lastWindow = windowStack[windowStack.Count - 1];
            CanvasGroup canvasGroup = lastWindow.GetComponent<CanvasGroup>();
            canvasGroup.alpha = 1;
            canvasGroup.DOFade(0, 0.25f).OnComplete(()=>{lastWindow.SetActive(false);});
        }

        GameObject window = windowStack.Find((GameObject x)=>{return x.name.Contains(windowID.ToString());});
        if(window != null)
        {
            window.SetActive(true);
            windowStack.Remove(window);
            windowStack.Add(window);
        }
        else
        {
            window = GameObject.Instantiate(Resources.Load(GlobalDataStructure.PATH_UIPREFAB_WINDOW + windowID.ToString()) as GameObject);
            windowStack.Add(window);
        }

        if(windowStack.Count > 1)
        {
            CanvasGroup canvasGroup = window.GetComponent<CanvasGroup>();
            canvasGroup.alpha = 0;
            canvasGroup.DOFade(1, 0.5f);
        }
    }

        /// <summary>
        /// Constructor that takes the given message event args, bilingual document, source segment and target segment.
        /// </summary>
        /// <param name="messageEventArgs">message event arguments</param>
        /// <param name="bilingualDocument">bilingual document</param>
        /// <param name="sourceSegment">source segment</param>
        /// <param name="targetSegment">target segment</param>
        public CustomMessageControl(MessageEventArgs messageEventArgs, IBilingualDocument bilingualDocument, ISegment sourceSegment, ISegment targetSegment)
        {
            MessageEventArgs = messageEventArgs;
            BilingualDocument = bilingualDocument;
            SourceSegment = sourceSegment;
            TargetSegment = targetSegment;
            InitializeComponent();
            
            _sourceSegmentControl.Dock = DockStyle.Fill;
            _sourceSegmentPanel.Controls.Add(_sourceSegmentControl);

            _targetSegmentControl.Dock = DockStyle.Fill;
            _targetSegmentPanel.Controls.Add(_targetSegmentControl);

            UpdateMessage(messageEventArgs);
            UpdateSourceSegment(sourceSegment);
            UpdateTargetSegment((ISegment)targetSegment.Clone());
            UpdateProblemDescription(messageEventArgs);
            UpdateSuggestions(messageEventArgs);

            // make the target segment editable
            _targetSegmentControl.IsReadOnly = false;

            _suggestionsList.SelectedIndexChanged += _suggestionsList_SelectedIndexChanged;
        }

        public void printMsg(MessageEventArgs e)
        {
            if (e.messageSet)
              {

            Message receivedMsg = e.newMessage;
            String user = receivedMsg.sndUser.username;
            String time = AddUserTime(user, false);
            String messageStr;

            if (chatUser.isPasswordProtected())
            {
              String encStr = receivedMsg.messageStr;
              messageStr = Message.xorMsg(encStr, chatUser.getPassword());
            }
            else
            {
              messageStr = receivedMsg.messageStr;
            }
            DisplayMsg(time, messageStr, user);

            // Memory handle
            time = null;
              }
        }

 private void OnChannelOpenFailure(object sender, MessageEventArgs<ChannelOpenFailureMessage> e)
 {
     if (e.Message.LocalChannelNumber == this.LocalChannelNumber)
     {
         this.OnOpenFailure(e.Message.ReasonCode, e.Message.Description, e.Message.Language);
     }
 }

        private void Session_MessageReceived(object sender, MessageEventArgs<Message> e)
        {
            var groupMessage = e.Message as KeyExchangeDhGroupExchangeGroup;

            if (groupMessage != null)
            {
                //  Unregister message once received
                this.Session.UnRegisterMessage("SSH_MSG_KEX_DH_GEX_GROUP");

                //  2. Receive SSH_MSG_KEX_DH_GEX_GROUP
                this._prime = groupMessage.SafePrime;
                this._group = groupMessage.SubGroup;

                this.PopulateClientExchangeValue();

                //  3. Send SSH_MSG_KEX_DH_GEX_INIT
                this.Session.SendMessage(new KeyExchangeDhGroupExchangeInit(this._clientExchangeValue));

            }
            var replyMessage = e.Message as KeyExchangeDhGroupExchangeReply;

            if (replyMessage != null)
            {
                //  Unregister message once received
                this.Session.UnRegisterMessage("SSH_MSG_KEX_DH_GEX_REPLY");

                this.HandleServerDhReply(replyMessage.HostKey, replyMessage.F, replyMessage.Signature);

                //  When SSH_MSG_KEX_DH_GEX_REPLY received key exchange is completed
                this.Finish();
            }
        }

 void OnMessageSet(MessageEventArgs args)
 {
     string msg = args.GetMessage<string>("Message");
     message.text = msg;
     msgList.Clear();
     msgList.Add(msg);
 }

 private void OnChannelOpenConfirmation(object sender, MessageEventArgs<ChannelOpenConfirmationMessage> e)
 {
     if (e.Message.LocalChannelNumber == this.LocalChannelNumber)
     {
         this.OnOpenConfirmation(e.Message.RemoteChannelNumber, e.Message.InitialWindowSize, e.Message.MaximumPacketSize);
     }
 }

 private void SocketMessage(object sender, MessageEventArgs e)
 {
     if ( e!= null && e.Message.Event == "message") {
         string msg = e.Message.MessageText;
         Debug.Log("socket message: " + msg);
     }
 }

 private void OnMarketPricesStreamMessageReceived(object sender, MessageEventArgs<PriceDTO> e)
 {
     if (!_listening) return;
     Dispatcher.BeginInvoke(() => listBox1.Items.Add("anonymous price arrived!"));
     Dispatcher.BeginInvoke(() => button1.IsEnabled = true);
     _listening = false;
 }

        private void OnMarketPricesStreamMessageReceived(object sender, MessageEventArgs<PriceDTO> e)
        {
            if (!_listening || _ordered || Market == null) return;
            _ordered = true;

            var order = new NewTradeOrderRequestDTO
            {
                MarketId = e.Data.MarketId,
                BidPrice = e.Data.Bid,
                OfferPrice = e.Data.Offer,
                AuditId = e.Data.AuditId,
                Quantity = Market.WebMinSize.GetValueOrDefault() + 1,
                TradingAccountId = Account.TradingAccounts[0].TradingAccountId,
                Direction = "buy"
            };

            Dispatcher.BeginInvoke(() => listBox1.Items.Add("price update arrived, making a new trade"));
            RpcClient.TradesAndOrders.BeginTrade(order, ar =>
            {
                var result = RpcClient.TradesAndOrders.EndTrade(ar);
                var newOrder = result.Orders.Length > 0 && result.Orders[0].OrderId == result.OrderId
                    ? result.Orders[0]
                    : null;

                if (newOrder != null && newOrder.Status == 8 && newOrder.StatusReason == 140)
                {
                    Dispatcher.BeginInvoke(() =>
                    {
                        listBox1.Items.Add("the account is on a dealer watchlist!");
                        listBox1.Items.Add("waiting for the order approval...");
                    });
                }
            }, null);
        }

        public NumberVerifierMessageUI(MessageEventArgs messageEventArgs, IBilingualDocument bilingualDocument, ISegment sourceSegment, ISegment targetSegment)
        {
            MessageEventArgs = messageEventArgs;
            BilingualDocument = bilingualDocument;
            SourceSegment = sourceSegment;
            TargetSegment = targetSegment;
            InitializeComponent();
            
            _sourceSegmentControl.Dock = DockStyle.Fill;
            _sourceSegmentControl.IsReadOnly = false;
            _sourceSegmentControl.ReplaceDocumentSegment(sourceSegment.Clone() as ISegment);
            panel_Source.Controls.Add(_sourceSegmentControl);
            _sourceSegmentControl.ReplaceDocumentSegment(sourceSegment);

            _targetSegmentControl.Dock = DockStyle.Fill;
            _targetSegmentControl.IsReadOnly = false;
            _targetSegmentControl.ReplaceDocumentSegment(targetSegment.Clone() as ISegment);
            panel_Target.Controls.Add(_targetSegmentControl);
            _targetSegmentControl.ReplaceDocumentSegment((ISegment)targetSegment.Clone());

            _targetSegmentControl.SegmentContentChanged += OnSegmentContentChanged;

            _hasSegmentChanged = false;

            UpdateMessage(messageEventArgs);


        }

        private void Session_ChannelOpening(object sender, MessageEventArgs<ChannelOpenMessage> e)
        {
            //  Ensure that this is corresponding request
            var info = e.Message.Info as ForwardedTcpipChannelInfo;
            if (info != null)
            {
                if (info.ConnectedAddress == this.BoundHost && info.ConnectedPort == this.BoundPort)
                {
                    this.ExecuteThread(() =>
                    {
                        try
                        {
                            this.RaiseRequestReceived(info.OriginatorAddress, info.OriginatorPort);

                            var channel = this.Session.CreateChannel<ChannelForwardedTcpip>(e.Message.LocalChannelNumber, e.Message.InitialWindowSize, e.Message.MaximumPacketSize);
                            channel.Bind(this.Host, this.Port);
                        }
                        catch (Exception exp)
                        {
                            this.RaiseExceptionEvent(exp);
                        }
                    });
                }
            }
        }

 void OnMessageUpdate(MessageEventArgs args)
 {
     string msg = args.GetMessage<string>("Message");
     //handle msgList
     msgList.Add(msg);
     while(msgList.Count > MAX_MSG_COUNT)
     {
         msgList.RemoveAt(0);
     }
     //handle alignment
     if (msgList.Count >= ALIGNMENT_MSG_COUNT)
     {
         message.alignment = TextAnchor.LowerLeft;
     }
     else
     {
         message.alignment = TextAnchor.UpperLeft;
     }
     //reassamble message
     message.text = "";
     for(int i = 0; i < msgList.Count - 1; i++)
     {
         message.text += msgList[i] + "\n";
     }
     //highlight latest message with animation
     message.DOKill();
     message.DOText(message.text + "<color=yellow>" + msgList[msgList.Count - 1] + "</color>", 0.5f).SetEase(Ease.Linear);
 }

        public IMessageResponse Execute()
        {
            if (Subject.Queue.Count == 0)
                return MessageResult.Empty;

            var ctx = (MessageResult)Subject.Queue.Dequeue();
            
            var handlers = Subject.Subscriber.Observers;


            if (handlers.Count == 0)
                OnCompleted(ctx);
            else
            {
                var e = new MessageEventArgs(ctx);

                ListnerManager.OnSending(e);

                if (e.Context.Response.Canceled)
                {
                    ListnerManager.OnSent(e);
                    OnCompleted(ctx);
                    return ctx;
                }

                Dispatch(ctx);
            }
                

            return ctx;
        }