/*
 * FILE: CECShortcutSet.cs
 *
 * DESCRIPTION: Shortcut set management
 *
 * CREATED BY: Duyuxin, 2005/1/5
 * CONVERTED TO C#: 2025
 *
 * HISTORY: 
 *
 * Copyright (c) 2005 Archosaur Studio, All Rights Reserved.
 */

using BrewMonster.Assets.PerfectWorld.Scripts.Skills;
using BrewMonster.Network;
using BrewMonster.Scripts.Skills;
using CSNetwork.GPDataType;
using System;
using System.Collections.Generic;
using Unity.VisualScripting;
using UnityEngine;

namespace BrewMonster
{
    /// <summary>
    /// Manages a set of shortcuts for quick access to items, skills, commands, etc.
    /// </summary>
    public class CECShortcutSet
    {
        #region Fields

        private List<CECShortcut> m_aShortcuts; // Shortcut array

        #endregion

        #region Constructor and Destructor

        public CECShortcutSet()
        {
            m_aShortcuts = new List<CECShortcut>();
        }

        #endregion

        #region Initialization and Release

        /// <summary>
        /// Initialize the shortcut set with a specified size
        /// </summary>
        /// <param name="iSize">Number of shortcut slots</param>
        /// <returns>True if successful</returns>
        public bool Init(int iSize)
        {
            m_aShortcuts = new List<CECShortcut>(iSize);
            for (int i = 0; i < iSize; i++)
            {
                m_aShortcuts.Add(null);
            }

            return true;
        }

        /// <summary>
        /// Release all shortcuts and clear the set
        /// </summary>
        public void Release()
        {
            // Clear all shortcuts
            for (int i = 0; i < m_aShortcuts.Count; i++)
            {
                if (m_aShortcuts[i] != null)
                {
                    // In C#, we don't need explicit deletion, just clear references
                    m_aShortcuts[i] = null;
                }
            }

            m_aShortcuts.Clear();
        }

        #endregion

        #region Shortcut Creation Methods

        /// <summary>
        /// Create an item shortcut at specified position
        /// </summary>
     /*   public bool CreateItemShortcut(int iSlot, int iIvtr, int iIvtrSlot, CECIvtrItem pItem)
        {
            CECSCItem pItemSC = new CECSCItem();
            if (pItemSC == null)
                return false;

            if (!pItemSC.Init(iIvtr, iIvtrSlot, pItem))
            {
                Debug.LogError("CECShortcutSet::CreateItemShortcut, Failed to initialize item shortcut");
                return false;
            }

            SetShortcut(iSlot, pItemSC);
            return true;
        }*/

        /// <summary>
        /// Create a skill shortcut at specified position
        /// </summary>
        public bool CreateSkillShortcut(int iSlot, CECSkill pSkill)
        {
            CECSCSkill pSkillSC = new CECSCSkill();
            if (pSkillSC == null)
                return false;

            if (!pSkillSC.Init(pSkill))
            {
                Debug.LogError("CECShortcutSet::CreateSkillShortcut, Failed to initialize skill shortcut");
                return false;
            }

            SetShortcut(iSlot, pSkillSC);
            return true;
        }

        /// <summary>
        /// Create a skill group shortcut at specified position
        /// </summary>
       /* public bool CreateSkillGroupShortcut(int iSlot, int iGroupIdx)
        {
            CECSCSkillGrp pSkillGrpSC = new CECSCSkillGrp();
            if (pSkillGrpSC == null)
                return false;

            if (!pSkillGrpSC.Init(iGroupIdx))
            {
                Debug.LogError("CECShortcutSet::CreateSkillGroupShortcut, Failed to initialize skill group shortcut");
                return false;
            }

            SetShortcut(iSlot, pSkillGrpSC);
            return true;
        }*/

        /// <summary>
        /// Create a pet shortcut at specified position
        /// </summary>
      /*  public bool CreatePetShortcut(int iSlot, int iPetIndex)
        {
            CECSCPet pPetSC = new CECSCPet();
            if (pPetSC == null)
                return false;

            if (!pPetSC.Init(iPetIndex))
            {
                Debug.LogError("CECShortcutSet::CreatePetShortcut, Failed to initialize pet shortcut");
                return false;
            }

            SetShortcut(iSlot, pPetSC);
            return true;
        }*/

        /// <summary>
        /// Create an auto fashion shortcut at specified position
        /// </summary>
     /*   public bool CreateAutoFashionShortcut(int iSlot, int iFashionIdx)
        {
            CECSCAutoFashion pAutoFashionSC = new CECSCAutoFashion();
            if (pAutoFashionSC == null)
                return false;

            if (!pAutoFashionSC.Init(iFashionIdx))
            {
                Debug.LogError("CECShortcutSet::CreateAutoFashionShortcut, Failed to initialize auto fashion shortcut");
                return false;
            }

            SetShortcut(iSlot, pAutoFashionSC);
            return true;
        }

        /// <summary>
        /// Create a system module shortcut at specified position
        /// </summary>
        public bool CreateSystemModuleShortcut(int iSlot, int iSys)
        {
            CECSCSysModule pSysModule = new CECSCSysModule();
            if (pSysModule == null)
                return false;

            if (!pSysModule.Init(iSys))
            {
                Debug.LogError("CECShortcutSet::CreateSystemModuleShortcut, Failed to initialize system module shortcut");
                return false;
            }

            SetShortcut(iSlot, pSysModule);
            return true;
        }*/

        /// <summary>
        /// Duplicate a shortcut to specified position
        /// </summary>
     /*   public bool CreateClonedShortcut(int iSlot, CECShortcut pShortcut)
        {
            CECShortcut pDest = pShortcut.Clone();
            if (pDest == null)
                return false;

            SetShortcut(iSlot, pDest);
            return true;
        }*/

        #endregion

        #region Shortcut Management

        /// <summary>
        /// Put a shortcut into set and return the old shortcut at that position
        /// </summary>
        /// <param name="iSlot">Slot index</param>
        /// <param name="pShortcut">Shortcut to place</param>
        /// <returns>Previous shortcut at that position</returns>
        public CECShortcut PutShortcut(int iSlot, CECShortcut pShortcut)
        {
            if (iSlot < 0 || iSlot >= m_aShortcuts.Count)
                return null;

            CECShortcut pOldShortcut = m_aShortcuts[iSlot];
            m_aShortcuts[iSlot] = pShortcut;
            return pOldShortcut;
        }

        /// <summary>
        /// Get a shortcut from set
        /// </summary>
        /// <param name="iSlot">Slot index</param>
        /// <param name="bRemove">If true, remove the shortcut from the set</param>
        /// <returns>Shortcut at the specified position</returns>
        public CECShortcut GetShortcut(int iSlot, bool bRemove = false)
        {
            if (iSlot < 0 || iSlot >= m_aShortcuts.Count)
                return null;

            CECShortcut pShortcut = m_aShortcuts[iSlot];
            if (bRemove)
                m_aShortcuts[iSlot] = null;

            return pShortcut;
        }

        /// <summary>
        /// Set a shortcut into set and release old shortcut at this position automatically
        /// </summary>
        public void SetShortcut(int iSlot, CECShortcut pShortcut)
        {
            if (iSlot < 0 || iSlot >= m_aShortcuts.Count)
                return;

            // Clear old shortcut (C# garbage collection will handle cleanup)
            if (m_aShortcuts[iSlot] != null)
            {
                m_aShortcuts[iSlot] = null;
            }

            m_aShortcuts[iSlot] = pShortcut;
        }

        /// <summary>
        /// Exchange shortcuts in two slots
        /// </summary>
        public void ExchangeShortcut(int iSlot1, int iSlot2)
        {
            if (iSlot1 < 0 || iSlot1 >= m_aShortcuts.Count ||
                iSlot2 < 0 || iSlot2 >= m_aShortcuts.Count)
                return;

            if (iSlot1 != iSlot2)
            {
                CECShortcut pShortcut = m_aShortcuts[iSlot1];
                m_aShortcuts[iSlot1] = m_aShortcuts[iSlot2];
                m_aShortcuts[iSlot2] = pShortcut;
            }
        }

        /// <summary>
        /// Remove all shortcuts
        /// </summary>
        public void RemoveAllShortcuts()
        {
            for (int i = 0; i < m_aShortcuts.Count; i++)
            {
                if (m_aShortcuts[i] != null)
                {
                    m_aShortcuts[i] = null;
                }
            }
        }

        /// <summary>
        /// Remove skill and skill group shortcuts
        /// </summary>
        public void RemoveSkillShortcuts()
        {
            for (int i = 0; i < m_aShortcuts.Count; i++)
            {
                CECShortcut pSC = m_aShortcuts[i];
                if (pSC == null)
                    continue;

                if (pSC.GetType() == (int)CECShortcut.ShortcutType.SCT_SKILL ||
                    pSC.GetType() == (int)CECShortcut.ShortcutType.SCT_SKILLGRP)
                {
                    m_aShortcuts[i] = null;
                }
            }
        }

        #endregion

        #region Update Methods

        /// <summary>
        /// Update item shortcut when item position changed
        /// </summary>
      /*  public void UpdateMovedItemSC(int tidItem, int iSrcIvtr, int iSrcSlot, int iDstIvtr, int iDstSlot)
        {
            for (int i = 0; i < m_aShortcuts.Count; i++)
            {
                CECShortcut pSC = m_aShortcuts[i];
                if (pSC == null || pSC.GetType() != CECShortcut.ShortcutType.SCT_ITEM)
                    continue;

                CECSCItem pItemSC = (CECSCItem)pSC;
                if (pItemSC.GetInventory() == iSrcIvtr && pItemSC.GetIvtrSlot() == iSrcSlot)
                {
                    Debug.Assert(pItemSC.GetItemTID() == tidItem);
                    pItemSC.MoveItem(iDstIvtr, iDstSlot);
                }
            }
        }*/

        /// <summary>
        /// Update item shortcut when item removed
        /// </summary>
      /*  public void UpdateRemovedItemSC(int tidItem, int iIvtr, int iSlot, int iSameItem)
        {
            for (int i = 0; i < m_aShortcuts.Count; i++)
            {
                CECShortcut pSC = m_aShortcuts[i];
                if (pSC == null || pSC.GetType() != CECShortcut.ShortcutType.SCT_ITEM)
                    continue;

                CECSCItem pItemSC = (CECSCItem)pSC;
                if (pItemSC.GetInventory() == iIvtr && pItemSC.GetIvtrSlot() == iSlot)
                {
                    Debug.Assert(pItemSC.GetItemTID() == tidItem);

                    if (pItemSC.GetAutoFindFlag() && iSameItem >= 0)
                        pItemSC.MoveItem(iIvtr, iSameItem);
                    else
                        SetShortcut(i, null);
                }
            }
        }*/

        /// <summary>
        /// Update item shortcut when two items exchanged
        /// </summary>
        /*public void UpdateExchangedItemSC(int tidItem1, int iIvtr1, int iSlot1,
                                          int tidItem2, int iIvtr2, int iSlot2)
        {
            for (int i = 0; i < m_aShortcuts.Count; i++)
            {
                CECShortcut pSC = m_aShortcuts[i];
                if (pSC == null || pSC.GetType() != CECShortcut.ShortcutType.SCT_ITEM)
                    continue;

                CECSCItem pItemSC = (CECSCItem)pSC;

                if (pItemSC.GetInventory() == iIvtr1 && pItemSC.GetIvtrSlot() == iSlot1)
                {
                    Debug.Assert(pItemSC.GetItemTID() == tidItem1);
                    pItemSC.MoveItem(iIvtr2, iSlot2);
                }
                else if (pItemSC.GetInventory() == iIvtr2 && pItemSC.GetIvtrSlot() == iSlot2)
                {
                    Debug.Assert(pItemSC.GetItemTID() == tidItem2);
                    pItemSC.MoveItem(iIvtr1, iSlot1);
                }
            }
        }

        /// <summary>
        /// Update pet shortcut when pet freed
        /// </summary>
        public void UpdateFreedPetSC(int iPetIndex)
        {
            for (int i = 0; i < m_aShortcuts.Count; i++)
            {
                CECShortcut pSC = m_aShortcuts[i];
                if (pSC == null || pSC.GetType() != CECShortcut.ShortcutType.SCT_PET)
                    continue;

                CECSCPet pPetSC = (CECSCPet)pSC;
                if (pPetSC.GetPetIndex() == iPetIndex)
                    SetShortcut(i, null);
            }
        }*/

        #endregion

        #region Skill Management

        /// <summary>
        /// Replace skill id in skill shortcuts
        /// </summary>
        public void ReplaceSkillID(int idOld, CECSkill pNewSkill)
        {
            for (int i = 0; i < m_aShortcuts.Count; i++)
            {
                CECShortcut pSC = m_aShortcuts[i];
                if (pSC == null || pSC.GetType() != (int)CECShortcut.ShortcutType.SCT_SKILL)
                    continue;

                // Replace skill
                CECSCSkill pSkillSC = (CECSCSkill)pSC;
                CECSkill pSkill = pSkillSC.GetSkill();
                if (pSkill.GetSkillID() == idOld)
                    pSkillSC.SetSkill(pNewSkill);
            }
        }

        /// <summary>
        /// Replace skill id in skill shortcuts using skill array
        /// </summary>
        public void ReplaceSkillID(SkillArrayWrapper skillArray, CECSkill pNewSkill)
        {
            for (int i = 0; i < skillArray.Count(); i++)
            {
                ReplaceSkillID((int)skillArray[i], pNewSkill);
            }
        }

        /// <summary>
        /// Remove skill shortcut by skill ID
        /// </summary>
        public bool RemoveSkillShortcut(int idSkill)
        {
            bool bRemove = false;

            for (int i = 0; i < GetShortcutNum(); i++)
            {
                CECShortcut pSC = GetShortcut(i);
                if (pSC == null)
                    continue;

                if (pSC.GetType() == (int)CECShortcut.ShortcutType.SCT_SKILL)
                {
                    CECSCSkill pSkillSC = (CECSCSkill)pSC;
                    CECSkill pSkill = pSkillSC.GetSkill();
                    if (pSkill != null && pSkill.GetSkillID() == idSkill)
                    {
                        SetShortcut(i, null);
                        bRemove = true;
                        continue;
                    }
                }
            }

            return bRemove;
        }

        #endregion

        #region Serialization

        /// <summary>
        /// Save shortcut configs to specified buffer
        /// </summary>
        public bool SaveConfigData(out byte[] dataBuffer)
        {
            List<byte> data = new List<byte>();

            for (int i = 0; i < m_aShortcuts.Count; i++)
            {
                CECShortcut pSC = m_aShortcuts[i];
                if (pSC == null)
                    continue;

                // Record shortcut's position and type
                data.AddRange(BitConverter.GetBytes(i));
                data.AddRange(BitConverter.GetBytes((int)pSC.GetType()));

                switch ((CECShortcut.ShortcutType)pSC.GetType())
                {
                    /* case CECShortcut.ShortcutType.SCT_COMMAND:
                         {
                             CECSCCommand cmdSC = (CECSCCommand)pSC;
                             data.AddRange(BitConverter.GetBytes(cmdSC.GetCommandID()));
                             data.AddRange(BitConverter.GetBytes((int)cmdSC.GetParam()));
                             break;
                         }
 */
                    case CECShortcut.ShortcutType.SCT_SKILL:
                        {
                            CECSCSkill skillSC = (CECSCSkill)pSC;
                            data.AddRange(BitConverter.GetBytes(skillSC.GetSkill().GetSkillID()));
                            break;
                        }

                    /* case CECShortcut.ShortcutType.SCT_ITEM:
                         {
                             CECSCItem itemSC = (CECSCItem)pSC;
                             data.AddRange(BitConverter.GetBytes(itemSC.GetInventory()));
                             data.AddRange(BitConverter.GetBytes(itemSC.GetIvtrSlot()));
                             data.AddRange(BitConverter.GetBytes(itemSC.GetItemTID()));
                             break;
                         }

                     case CECShortcut.ShortcutType.SCT_SKILLGRP:
                         {
                             CECSCSkillGrp skillGrpSC = (CECSCSkillGrp)pSC;
                             data.AddRange(BitConverter.GetBytes(skillGrpSC.GetGroupIndex()));
                             break;
                         }

                     case CECShortcut.ShortcutType.SCT_PET:
                         {
                             CECSCPet petSC = (CECSCPet)pSC;
                             data.AddRange(BitConverter.GetBytes(petSC.GetPetIndex()));
                             break;
                         }

                     case CECShortcut.ShortcutType.SCT_AUTOFASHION:
                         {
                             CECSCAutoFashion fashionSC = (CECSCAutoFashion)pSC;
                             data.AddRange(BitConverter.GetBytes(fashionSC.GetAutoFashionIndex()));
                             break;
                         }

                     case CECShortcut.ShortcutType.SCT_SYSMODULE:
                         {
                             CECSCSysModule sysSC = (CECSCSysModule)pSC;
                             data.AddRange(BitConverter.GetBytes(sysSC.GetSysModID()));
                             break;
                         }*/

                    default:
                        Debug.LogError("CECShortcutSet::SaveConfigData - Unknown shortcut type");
                        break;
                }
            }

            // Add the end flag
            data.AddRange(BitConverter.GetBytes(-1));

            dataBuffer = data.ToArray();
            return true;
        }

        /// <summary>
        /// Load shortcut configs from specified buffer
        /// </summary>
        public bool LoadConfigData(byte[] pDataBuf, uint dwVer, ref int offset)
        {

            if (pDataBuf == null || pDataBuf.Length == 0)
            {
                return false;
            }

            CECGameRun pGameRun = EC_Game.GetGameRun();
            CECHostPlayer pHost = pGameRun.GetHostPlayer();
            Debug.Assert(pHost != null);

            while (offset < pDataBuf.Length)
            {
                int iSlot = GPDataTypeHelper.FromBytes<int>(pDataBuf, offset);
                offset += sizeof(int);

                if (iSlot < 0)
                    break; // Meet end flag

                int iSCType = GPDataTypeHelper.FromBytes<int>(pDataBuf, offset);
                offset += sizeof(int);

                switch ((CECShortcut.ShortcutType)iSCType)
                {
                    /*case CECShortcut.ShortcutType.SCT_COMMAND:
                        {
                            int iCommand = BitConverter.ToInt32(pDataBuf, offset);
                            offset += sizeof(int);

                            int iParam = 0;
                            if (dwVer >= 2)
                            {
                                iParam = BitConverter.ToInt32(pDataBuf, offset);
                                offset += sizeof(int);
                            }

                            CECSCCommand pCmdSC = null;
                            if (iCommand == CECSCCommand.CMD_PLAYPOSE)
                                pCmdSC = pGameRun.GetPoseCmdShortcut(iParam);
                            else
                                pCmdSC = pGameRun.GetCmdShortcut(iCommand);

                            if (pCmdSC != null)
                                CreateClonedShortcut(iSlot, pCmdSC);

                            break;
                        }*/

                    case CECShortcut.ShortcutType.SCT_SKILL:
                        {
                            int idSkill = BitConverter.ToInt32(pDataBuf, offset);
                            offset += sizeof(int);

                            CECSkill pSkill = pHost.GetPositiveSkillByID(idSkill, true);
                            if (pSkill == null)
                                pSkill = pHost.GetEquipSkillByID(idSkill);

                            CECSkill pSkill2 = null;
                            /*  CECHostGoblin pGoblin = (CECHostGoblin)pHost.GetGoblinModel();
                              if (pGoblin != null)
                              {
                                  pSkill2 = pGoblin.GetSkillByID(idSkill);
                              }*/

                            if (pSkill != null)
                                CreateSkillShortcut(iSlot, pSkill);
                            else if (pSkill2 != null)
                                CreateSkillShortcut(iSlot, pSkill2);

                            break;
                        }

                        /*  case CECShortcut.ShortcutType.SCT_ITEM:
                              {
                                  int iPack = BitConverter.ToInt32(pDataBuf, offset);
                                  offset += sizeof(int);
                                  int iIvtrSlot = BitConverter.ToInt32(pDataBuf, offset);
                                  offset += sizeof(int);
                                  int idItem = BitConverter.ToInt32(pDataBuf, offset);
                                  offset += sizeof(int);

                                  CECInventory pPack = pHost.GetPack(iPack);
                                  if (pPack == null)
                                  {
                                      Debug.LogError("CECShortcutSet::LoadConfigData - Invalid inventory");
                                      return false;
                                  }

                                  CECIvtrItem pItem = pPack.GetItem(iIvtrSlot);
                                  if (pItem != null)
                                      CreateItemShortcut(iSlot, iPack, iIvtrSlot, pItem);

                                  break;
                              }

                          case CECShortcut.ShortcutType.SCT_SKILLGRP:
                              {
                                  if (dwVer >= 3)
                                  {
                                      int iGroupIdx = BitConverter.ToInt32(pDataBuf, offset);
                                      offset += sizeof(int);

                                      if (iGroupIdx >= 0)
                                          CreateSkillGroupShortcut(iSlot, iGroupIdx);
                                  }
                                  else
                                  {
                                      Debug.LogError("CECShortcutSet::LoadConfigData - Invalid version for skill group");
                                      return false;
                                  }
                                  break;
                              }

                          case CECShortcut.ShortcutType.SCT_PET:
                              {
                                  if (dwVer >= 4)
                                  {
                                      int iPetIndex = BitConverter.ToInt32(pDataBuf, offset);
                                      offset += sizeof(int);

                                      if (iPetIndex >= 0)
                                          CreatePetShortcut(iSlot, iPetIndex);
                                  }
                                  else
                                  {
                                      Debug.LogError("CECShortcutSet::LoadConfigData - Invalid version for pet");
                                      return false;
                                  }
                                  break;
                              }

                          case CECShortcut.ShortcutType.SCT_AUTOFASHION:
                              {
                                  if (dwVer >= 5)
                                  {
                                      int iAutoFashionIndex = BitConverter.ToInt32(pDataBuf, offset);
                                      offset += sizeof(int);

                                      if (iAutoFashionIndex >= 0)
                                          CreateAutoFashionShortcut(iSlot, iAutoFashionIndex);
                                  }
                                  else
                                  {
                                      Debug.LogError("CECShortcutSet::LoadConfigData - Invalid version for auto fashion");
                                      return false;
                                  }
                                  break;
                              }

                          case CECShortcut.ShortcutType.SCT_SYSMODULE:
                              {
                                  if (dwVer > 10)
                                  {
                                      int iSys = BitConverter.ToInt32(pDataBuf, offset);
                                      offset += sizeof(int);

                                      if (iSys >= 0)
                                          CreateSystemModuleShortcut(iSlot, iSys);
                                  }
                                  else
                                  {
                                      Debug.LogError("CECShortcutSet::LoadConfigData - Invalid version for system module");
                                      return false;
                                  }
                                  break;
                              }*/

                        /*   default:
                               //TODO: uncomment 
                               //BMLogger.LogError("CECShortcutSet::LoadConfigData - Unknown shortcut type");
                               return false;*/
                }
            }

            return true;
        }

        #endregion

        #region Properties

        /// <summary>
        /// Get the number of shortcuts in the set
        /// </summary>
        public int GetShortcutNum()
        {
            return m_aShortcuts.Count;
        }

        #endregion
    }

    #region Placeholder Classes
    // These classes are referenced but not defined in the provided files
    // They should be implemented separately based on EC_Shortcut.h/cpp

    public class CECShortcut
    {
        protected int m_iSCType;

        public CECShortcut() { m_iSCType = (int)ShortcutType.SCT_UNKNOWN; }
        public enum ShortcutType
        {
            SCT_UNKNOWN = -1,
            SCT_SKILL = 0,
            SCT_ITEM,
            SCT_COMMAND,
            SCT_SKILLGRP,
            SCT_PET,
            SCT_AUTOFASHION,
            SCT_SYSMODULE,
        }

        public virtual int GetType()
        {
            return m_iSCType;
        }

        public virtual CECShortcut Clone()
        {
            return new CECShortcut();
        }
        public virtual bool Execute() { return true; }
    }

    public class CECSCCommand : CECShortcut
    {
        private int m_iCommand;		//	Command ID
        private uint m_dwParam;		//	Parameter
        public enum CommandID
        {
            CMD_UNKNOWN = -1,
            CMD_SITDOWN = 0,
            CMD_WALKRUN,
            CMD_NORMALATTACK,
            CMD_FINDTARGET,
            CMD_ASSISTATTACK,
            CMD_INVITETOTEAM,
            CMD_LEAVETEAM,	
            CMD_KICKTEAMMEM,
            CMD_FINDTEAM,
            CMD_STARTTRADE,
            CMD_SELLBOOTH,
            CMD_BUYBOOTH,
            CMD_PLAYPOSE,
            CMD_INVITETOFACTION,
            CMD_FLY,
            CMD_PICKUP,
            CMD_GATHER,
            CMD_RUSHFLY,
            CMD_BINDBUDDY,
        }
        public CECSCCommand(int iCommand)
        {
            m_iSCType  = (int)ShortcutType.SCT_COMMAND;
            m_iCommand = iCommand;
            m_dwParam  = 0;
        }

        public CECSCCommand(CECSCCommand src)
        {
            m_iCommand = src.m_iCommand;
            m_dwParam  = src.m_dwParam;
        }
        public const int CMD_PLAYPOSE = 1; // Example constant
        // public override ShortcutType GetType() => ShortcutType.SCT_COMMAND;
        public override CECShortcut Clone() => new CECSCCommand(this);
        public int GetCommandID() => 0;
        public int GetParam() => 0;
        
        //	Set / Get command parameter
        public void SetParam(uint dwParam) { m_dwParam = dwParam; }
        
        //	Execute shortcut
        public override bool Execute()
        {
            CECHostPlayer pHost = CECGameRun.Instance.GetHostPlayer();
            if (!pHost || !pHost.IsAllResReady())
                return false;

            // if (GetCoolTime(0)>0)
            // {
            //     bool bForbidCmd = true;
            //     if (m_iCommand == CMD_RUSHFLY && pHost.GetRushFlyFlag())
            //         bForbidCmd = false;
            //
            //     if (bForbidCmd)
            //     {
            //         g_pGame->GetGameRun()->AddFixedMessage(FIXMSG_CMD_INCOOLTIME);
            //         return false;
            //     }
            // }
            switch (m_iCommand)
            {
                // case CMD_SITDOWN: pHost->CmdSitDown(!pHost->IsSitting()); break;
                // case CMD_WALKRUN: pHost->CmdWalkRun(!pHost->GetWalkRunFlag()); break;
                // case CMD_NORMALATTACK: pHost->CmdNormalAttack(); break;
                // case CMD_FINDTARGET: pHost->CmdFindTarget(); break;
                // case CMD_ASSISTATTACK: pHost->CmdAssistAttack(); break;
                // case CMD_INVITETOTEAM: pHost->CmdInviteToTeam(); break;
                // case CMD_LEAVETEAM: pHost->CmdLeaveTeam(); break;
                // case CMD_KICKTEAMMEM: pHost->CmdKickTeamMember(); break;
                // case CMD_FINDTEAM: pHost->CmdFindTeam(); break;
                // case CMD_STARTTRADE: pHost->CmdStartTrade(); break;
                // case CMD_SELLBOOTH: pHost->CmdSellBooth(); break;
                // case CMD_BUYBOOTH: pHost->CmdBuyBooth(); break;
                case (int)CommandID.CMD_PLAYPOSE: pHost.CmdStartPose((int)m_dwParam); break;
                // case CMD_INVITETOFACTION: pHost->CmdInviteToFaction(); break;
                // case CMD_FLY:
                // {
                //     // Èç¹ûÆï³ËÒª·ÉÐУ¬ÔòÕâЩ action switcher£¬·ñÔò CmdFly
                //     if (!pHost->GetActionSwitcher() || !pHost->GetActionSwitcher()->OnRideToFlyAction())
                //         pHost->CmdFly();
                //     break;
                // }
                // case CMD_PICKUP: pHost->CmdPickup(); break;
                // case CMD_GATHER: pHost->CmdGather(); break;
                // case CMD_RUSHFLY: pHost->CmdRushFly(); break;
                // case CMD_BINDBUDDY: pHost->CmdBindBuddy(pHost->GetSelectedTarget()); break;
                default:
                    return false;
            }

            return true;
        }
        
        //	Get item cool time
        int GetCoolTime(ref int piMax/* NULL */)
        {
            CECHostPlayer pHost = CECGameRun.Instance.GetHostPlayer();
            int iTime = 0;

            switch ((CommandID)m_iCommand)
            {
                case CommandID.CMD_RUSHFLY:

                    // iTime = pHost.GetCoolTime(GP_CT_FLY_RUSH, piMax);
                    break;

                case CommandID.CMD_PLAYPOSE:
                    // todo need to get cooldown here
                    // iTime = pHost.GetCoolTime(GP_CT_EMOTE, piMax);
                    break;

                case CommandID.CMD_BINDBUDDY:
                {
                    // CECCounter& cnt = pHost->GetBindCmdCoolCnt();
                    // iTime = cnt.GetPeriod() - cnt.GetCounter();
                    //
                    // if (piMax)
                    //     *piMax = cnt.GetPeriod();

                    break;
                }
                default:

                    // if (piMax)	*piMax = 0;
                    break;
            }

            return iTime;
        }
    }

       /* public class CECSCSkill : CECShortcut
       {
           private CECSkill m_pSkill;
           public override ShortcutType GetType() => ShortcutType.SCT_SKILL;
           public override CECShortcut Clone() => null;
           public bool Init(CECSkill pSkill) { m_pSkill = pSkill; return true; }
           public CECSkill GetSkill() => m_pSkill;
           public void SetSkill(CECSkill pSkill) { m_pSkill = pSkill; }
       }

       public class CECSCItem : CECShortcut
       {
           private int m_iInventory;
           private int m_iIvtrSlot;
           private int m_iItemTID;
           private bool m_bAutoFind;

           public override ShortcutType GetType() => ShortcutType.SCT_ITEM;
           public override CECShortcut Clone() => null;
           public bool Init(int iIvtr, int iSlot, CECIvtrItem pItem) 
           { 
               m_iInventory = iIvtr; 
               m_iIvtrSlot = iSlot; 
               return true; 
           }
           public int GetInventory() => m_iInventory;
           public int GetIvtrSlot() => m_iIvtrSlot;
           public int GetItemTID() => m_iItemTID;
           public bool GetAutoFindFlag() => m_bAutoFind;
           public void MoveItem(int iIvtr, int iSlot) { m_iInventory = iIvtr; m_iIvtrSlot = iSlot; }
       }*/

    /*  public class CECSCSkillGrp : CECShortcut
      {
          private int m_iGroupIdx;
          public override ShortcutType GetType() => ShortcutType.SCT_SKILLGRP;
          public override CECShortcut Clone() => null;
          public bool Init(int iGroupIdx) { m_iGroupIdx = iGroupIdx; return true; }
          public int GetGroupIndex() => m_iGroupIdx;
      }

      public class CECSCPet : CECShortcut
      {
          private int m_iPetIndex;
          public override ShortcutType GetType() => ShortcutType.SCT_PET;
          public override CECShortcut Clone() => null;
          public bool Init(int iPetIndex) { m_iPetIndex = iPetIndex; return true; }
          public int GetPetIndex() => m_iPetIndex;
      }

      public class CECSCAutoFashion : CECShortcut
      {
          private int m_iFashionIdx;
          public override ShortcutType GetType() => ShortcutType.SCT_AUTOFASHION;
          public override CECShortcut Clone() => null;
          public bool Init(int iFashionIdx) { m_iFashionIdx = iFashionIdx; return true; }
          public int GetAutoFashionIndex() => m_iFashionIdx;
      }

      public class CECSCSysModule : CECShortcut
      {
          private int m_iSysModID;
          public override ShortcutType GetType() => ShortcutType.SCT_SYSMODULE;
          public override CECShortcut Clone() => null;
          public bool Init(int iSys) { m_iSysModID = iSys; return true; }
          public int GetSysModID() => m_iSysModID;
      }

      // Placeholder classes for dependencies
      public class CECIvtrItem { }
      public class CECInventory 
      { 
          public CECIvtrItem GetItem(int slot) => null; 
      }
      public class CECHostGoblin 
      { 
          public CECSkill GetSkillByID(int id) => null; 
      }*/
    #endregion
}