//---------------------------------------------------------------------------

#ifndef PacketHandllingFH
#define PacketHandllingFH
//---------------------------------------------------------------------------
#include "VmsProtocolF.h"

//---------------------------------------------------------------------------
#pragma pack(push, 1)
//---------------------------------------------------------------------------

/*
*****************************************************************************
*  ÇÁ·ÎÅäÄÝ ¼ö½Å OP Code
****************************************************************************/
typedef enum _e_vms_recv_packet
{
    e_rpkt_MIN                = 0x00,
    e_rpkt_VMS_ID_RES         = 0xFF,        // client -> server
    e_rpkt_NOTIFY_STTS        = 0x01,        // client -> server
    e_rpkt_DNLD_SCENARIO_RES  = 0x02,        // client -> server
    e_rpkt_CTRL_RESET_RES     = 0x03,        // client -> server
    e_rpkt_DNLD_FILE_RES      = 0x04,        // client -> server
    e_rpkt_PARAMETER_RES      = 0x05,        // client -> server
    e_rpkt_CTRL_LED_POWER_RES = 0x06,        // client -> server
    e_rpkt_CTRL_FAN_POWER_RES = 0x07,        // client -> server
    e_rpkt_CTRL_BRGH_RES      = 0x08,        // client -> server
    e_rpkt_CTRL_CONFIG_RES    = 0x09,        // client -> server
    e_rpkt_CTRL_TIME_RES      = 0x10,        // client -> server
    e_rpkt_MAX                = 0xFF+1,
} e_vms_recv_packet;

/*
*****************************************************************************
*  ÇÁ·ÎÅäÄÝ define
****************************************************************************/
#define MAX_PACKET_SIZE         4096

#define MAX_VMS_ID              10      /* '00000100001' */
#define MAX_DISP_TIME           12      /* YYYYMMDDHHMI */
#define MAX_SYS_TIME            14      /* YYYYMMDDHHMISS */
#define MAX_FILE_NAME           60

#define MAX_SCENARIO            INT_VMS_MAX_FORM
#define MAX_DNLD_FILE           INT_VMS_MAX_FORM

/*
*****************************************************************************
*  ÇÁ·ÎÅäÄÝ OP ÄÚµå Á¤ÀÇ
****************************************************************************/
#define VMS_STX                 0x02        // Start of TeXt
#define VMS_ETX                 0x03        // End of TeXt

#define VMS_NULL                0x00

#define VMS_ID_REQ              0xFF        // server -> client
#define VMS_ID_RES              0xFF        // client -> server

#define NOTIFY_STTS             0x01        // client -> server
#define NOTIFY_STTS_ACK         0x01        // server -> client

#define DNLD_SCENARIO_REQ       0x02        // server -> client
#define DNLD_SCENARIO_RES       0x02        // client -> server

#define CTRL_RESET_REQ          0x03        // server -> client
#define CTRL_RESET_RES          0x03        // client -> server

#define DNLD_FILE_REQ           0x04        // server -> client
#define DNLD_FILE_RES           0x04        // client -> server

#define PARAMETER_REQ           0x05        // server -> client
#define PARAMETER_RES           0x05        // client -> server

#define CTRL_LED_POWER_REQ      0x06        // server -> client
#define CTRL_LED_POWER_RES      0x06        // client -> server

#define CTRL_FAN_POWER_REQ      0x07        // server -> client
#define CTRL_FAN_POWER_RES      0x07        // client -> server

#define CTRL_BRGH_REQ           0x08        // server -> client
#define CTRL_BRGH_RES           0x08        // client -> server

#define CTRL_CONFIG_REQ         0x09        // server -> client
#define CTRL_CONFIG_RES         0x09        // client -> server

#define CTRL_TIME_REQ           0x10        // server -> client
#define CTRL_TIME_RES           0x10        // client -> server

typedef struct _st_head
{
    _st_head()
    {
        Stx    = VMS_STX;
        OpCode = VMS_NULL;
        Length = 0;
    }
    BYTE Stx;
    BYTE OpCode;
    char vmsid[MAX_VMS_ID];
    WORD Length;
} st_head;

typedef struct _st_simple_req
{
    _st_simple_req()
    {
        Stx    = VMS_STX;
        OpCode = VMS_NULL;
        Length = 0;
        Etx    = VMS_ETX;
    }
    BYTE Stx;
    BYTE OpCode;
    char vmsid[MAX_VMS_ID];
    WORD Length;
    BYTE Etx;
} st_simple_req;


/*
*  VMS ID ¿äû/ÀÀ´ä (server -> client)
****************************************************************************/
typedef struct _st_vms_id_req
{
    _st_vms_id_req()
    {
        Stx    = VMS_STX;
        OpCode = VMS_ID_REQ;
        Length = 0;
        Etx    = VMS_ETX;
    }
    BYTE Stx;
    BYTE OpCode;
    WORD Length;
    BYTE Etx;
} st_vms_id_req;

typedef struct _st_vms_id_res : public st_head
{
    _st_vms_id_res()
    {
        Length = 1;
        OpCode = (BYTE)e_rpkt_VMS_ID_RES;
        Ack    = 0x00;
        Etx    = VMS_ETX;
    }

    BYTE Ack;    // 0x00 : Á¤»ó
                 // 0x31 : µ¥ÀÌÅÍÅ©±â ºÒÀÏÄ¡
                 // 0x32 : CRC16 ¿¡·¯
                 // 0x33 : Á¤ÀǵÇÁö ¾ÊÀº OP_CODE
                 // 0x34 : ±âŸ
    BYTE Etx;
} st_vms_id_res;

#define ACK_NORMAL      0x00    // 0x00 : Á¤»ó
#define ACK_ERR_SIZE    0x31    // 0x31 : µ¥ÀÌÅÍÅ©±â ºÒÀÏÄ¡
#define ACK_ERR_CRD     0x32    // 0x32 : CRC16 ¿¡·¯
#define ACK_ERR_OPCODE  0x33    // 0x33 : Á¤ÀǵÇÁö ¾ÊÀº OP_CODE
#define ACK_ERR_ETC     0x34    // 0x34 : ±âŸ

typedef struct _st_ack
{
    _st_ack()
    {
        Stx    = VMS_STX;
        OpCode = VMS_NULL;
        Length = 1;
        Ack    = ACK_NORMAL;
        Etx    = VMS_ETX;
    }
    BYTE Stx;
    BYTE OpCode;
    char vmsid[MAX_VMS_ID];
    WORD Length;
    BYTE Ack;    // 0x00 : Á¤»ó
                 // 0x31 : µ¥ÀÌÅÍÅ©±â ºÒÀÏÄ¡
                 // 0x32 : CRC16 ¿¡·¯
                 // 0x33 : Á¤ÀǵÇÁö ¾ÊÀº OP_CODE
                 // 0x34 : ±âŸ
    BYTE Etx;
} st_ack;

/*
*  »óÅÂÁ¤º¸ ¼ö½Å Å뺸/ÀÀ´ä (client -> server)
****************************************************************************/
typedef struct _st_stts
{
    char time[MAX_SYS_TIME];  // ÇöÀç Á¦¾î±â ½Ã°£

    BYTE led;    // 0x00 : ÀÛµ¿¾ÈÇÔ
                 // 0x01 : ÀÛµ¿Áß
                 // 0x02 : ¾Ë¼ö¾øÀ½

    BYTE door;   // 0x00 : ´ÝÈû
                 // 0x01 : ¿­¸²
                 // 0x02 : ¾Ë¼ö¾øÀ½

    BYTE fan;    // 0x00 : ÀÛµ¿¾ÈÇÔ
                 // 0x01 : ÀÛµ¿Áß
                 // 0x02 : ¾Ë¼ö¾øÀ½

    BYTE hetr;   // 0x00 : ÀÛµ¿¾ÈÇÔ
                 // 0x01 : ÀÛµ¿Áß
                 // 0x02 : ¾Ë¼ö¾øÀ½

    BYTE tmpr;   // ¿Âµµ°ª( 0x00~0x3f)
    BYTE brgh;   // ÇöÀçÀÇ ÈÖµµ°ª(0x00~0x3f)

    BYTE comm;   // 0x00 : Á¤»ó
                 // 0x01 : ºñÁ¤»ó
} st_stts;

typedef struct _st_notify_stts : public st_head
{
    _st_notify_stts()
    {
        Length = sizeof(st_stts);
    }
    st_stts stts;
    BYTE    Etx;
} st_notify_stts;

typedef struct _st_notify_stts_ack : public st_head
{
    _st_notify_stts_ack()
    {
        OpCode = NOTIFY_STTS_ACK;
        Length = 1;
        Ack    = 0x00;
        Etx    = VMS_ETX;
    }
    BYTE Ack;    // 0x00 : Á¤»ó
                 // 0x31 : µ¥ÀÌÅÍÅ©±â ºÒÀÏÄ¡
                 // 0x32 : CRC16 ¿¡·¯
                 // 0x33 : Á¤ÀǵÇÁö ¾ÊÀº OP_CODE
                 // 0x34 : ±âŸ
    BYTE Etx;
} st_notify_stts_ack;

/*
*  ½Ã³ª¸®¿À ´Ù¿î·Îµå ¿äû/ÀÀ´ä (server -> client)
****************************************************************************/
#define P_FILE_TYPE_IMAGE       0x01
#define P_FILE_TYPE_VIDEO       0x02
#define P_FILE_TYPE_STREAM      0x03
#define P_FILE_TYPE_TRAFFIC     0x04
#define P_FILE_TYPE_TEXT        0x05

typedef struct _st_scenario
{
    BYTE    seq;                        // ½Ã³ª¸®¿À ¼ø¹ø
    BYTE    type;                       // 0x01 : À̹ÌÁö (JPG)
                                        // 0x02 : 樨毢 (AVI)
                                        // 0x03 : URL(½ºÆ®¸®¹Ö)
                                        // 0x04 : ¼ÒÅë À̹ÌÁö
                                        // 0x05 : Ç¥Ãâ¹®±¸ À̹ÌÁö
    BYTE    dispEffect;                 // Ç¥ÃâŸÀÔÀÌ À̹ÌÁöÀÏ °æ¿ì¿¡¸¸ È¿ÃâÈ¿°ú°¡ Àû¿ëµÈ´Ù.
                                        // 0x00 : Static (񃧯)
                                        // 0x01 : Blink

    char    fileName[MAX_FILE_NAME];    // ÆÄÀϸí
                                        // ¡Ø Ç¥Ãâ ŸÀÔº° FTP Æú´õ °³¼³

    BYTE    dispTm;                     // Ç¥Ãâ¹®±¸ Ç¥Ãâ½Ã°¢('03' : 3ÃÊ)
    char    dispStrTm[MAX_DISP_TIME];   // Ç¥Ãâ½ÃÀ۽ð£(0000 00 00 0000)
    char    dispEndTm[MAX_DISP_TIME];   // Ç¥ÃâÁ¾·á½Ã°¢(999912312359)
    BYTE    dnldFlag;                   // ÆÄÀÏ´Ù¿î·Îµå ¿©ºÎ D : ´Ù¿î·Îµå
                                        //                   C : ºñ±³ÈÄ ´Ù¿î·Îµå(¾øÀ»°æ¿ì)
} st_scenario;

typedef struct _st_dnld_scenario_req : public st_head
{
    _st_dnld_scenario_req()
    {
        OpCode = DNLD_SCENARIO_REQ;
    }
    BYTE    type;
    BYTE    cnt;     // ÇØ´ç VMSÀÇ Àüü½Ã³ª¸®¿À ¼ö
    st_scenario scenario[MAX_SCENARIO+1];
} st_dnld_scenario_req;

typedef st_ack  st_dnld_scenario_res;


/*
*  ÆÄÀÏ ´Ù¿î·Îµå ¿äû/ÀÀ´ä (server -> client)
****************************************************************************/
typedef struct _st_dnld_file
{
    BYTE    type;                       // Ç¥ÃâŸÀÔ 0x01 : À̹ÌÁö (JPG)
                                        //          0x02 : 樨毢 (AVI)
    char    fileName[MAX_FILE_NAME];    // ÆÄÀϸí
                                        // ¡Ø VMS ID ¹× Ç¥Ãâ ŸÀÔº° FTP Æú´õ °³¼³
} st_dnld_file;

typedef struct _st_dnld_file_req : public st_head
{
    _st_dnld_file_req()
    {
        OpCode = DNLD_FILE_REQ;
    }
    char cnt[2];     // Àü¼Û ÆÄÀϼö
    union
    {
        st_dnld_file file[MAX_DNLD_FILE];
        char         data[sizeof(st_dnld_file)*MAX_DNLD_FILE+1];
    } U;
} st_dnld_file_req;

typedef st_ack  st_dnld_file_res;

/*
*  ÆĶó¹ÌÅÍ°ª ¿äû/ÀÀ´ä (server -> client)
****************************************************************************/
typedef st_simple_req st_parameter_req;

typedef struct _st_parameter
{
    BYTE    led;        // 0x00 : ²¨Áü
                        // 0x01 : ÄÑÁü
                        // 0x02 : ÀÚµ¿
                        // 0x09 : ¾Ë¼ö¾øÀ½

    BYTE    fan;        // 0x00 : ²¨Áü
                        // 0x01 : ÄÑÁü
                        // 0x02 : ÀÚµ¿
                        // 0x09 : ¾Ë¼ö¾øÀ½

    BYTE    fanTmpr;    // Fan µ¿Àۿµµ(0x00~0x3f)

    BYTE    hetr;       // 0x00 : ²¨Áü
                        // 0x01 : ÄÑÁü
                        // 0x02 : ÀÚµ¿
                        // 0x09 : ¾Ë¼ö¾øÀ½

    BYTE    hetrTmpr;   // Heater µ¿Àۿµµ(0x00~0x3f)

    BYTE    brgh;       // 0x00 : ÁÖ°£
                        // 0x01 : ¾ß°£
                        // 0x02 : ÀÚµ¿
                        // 0x09 : ¼öµ¿

    BYTE    brghVal;   // ÇöÀçÈÖµµ°ª (0 ~ 100)
    BYTE    brghDay;   // ÁÖ°£ ÈÖµµ°ª(0 ~ 100)
    BYTE    brghNight; // ¾ß°£ ÈÖµµ°ª(0 ~ 100)

    char    time[MAX_SYS_TIME];  // ÇöÀç Á¦¾î±â ½Ã°£
} st_parameter;

typedef struct _st_parameter_res : public st_head
{
    _st_parameter_res()
    {
    }
    BYTE            Ack;
    st_parameter    para;
    BYTE            Etx;
} st_parameter_res;

/*
*  LED Àü¿øÁ¦¾î ¿äû/ÀÀ´ä (server -> client)
****************************************************************************/
typedef struct _st_ctrl_led_power_req : public st_head
{
    _st_ctrl_led_power_req()
    {
        OpCode = CTRL_LED_POWER_REQ;
        Etx    = VMS_ETX;
        Length = 1;
    }
    BYTE cmd;    // LED Àü¿ø ON/OFF Á¦¾î Á¤º¸ ON  - 1
                 //                           OFF - 0
    BYTE Etx;
} st_ctrl_led_power_req;

typedef st_ack  st_ctrl_led_power_res;

/*
*  FAN Àü¿øÁ¦¾î ¿äû/ÀÀ´ä (server -> client)
****************************************************************************/
typedef struct _st_ctrl_fan_power_req : public st_head
{
    _st_ctrl_fan_power_req()
    {
        OpCode = CTRL_FAN_POWER_REQ;
        Etx    = VMS_ETX;
        Length = 1;
    }
    BYTE cmd;    // FAN Àü¿ø ON/OFF Á¦¾î Á¤º¸ ON  - 1
                    //                           OFF - 0
    BYTE Etx;
} st_ctrl_fan_power_req;

typedef st_ack  st_ctrl_fan_power_res;

/*
*  ÈÖµµ Á¦¾î ¿äû/ÀÀ´ä (server -> client)
****************************************************************************/
typedef struct _st_brgh
{
    BYTE    brgh;       // 0x00 : ÁÖ°£
                        // 0x01 : ¾ß°£
                        // 0x02 : ÀÚµ¿
                        // 0x09 : ¼öµ¿

    byte    brghVal;   // ÇöÀçÈÖµµ°ª (0 ~ 100)
    byte    brghDay;   // ÁÖ°£ ÈÖµµ°ª(0 ~ 100)
    byte    brghNight; // ¾ß°£ ÈÖµµ°ª(0 ~ 100)
} st_brgh;

typedef struct _st_ctrl_brgh_req : public st_head
{
    _st_ctrl_brgh_req()
    {
        OpCode = CTRL_BRGH_REQ;
        Length = sizeof(st_brgh);
        Etx    = VMS_ETX;
    }
    st_brgh set;
    BYTE    Etx;
} st_ctrl_brgh_req;

typedef st_ack  st_ctrl_brgh_res;

/*
*  ȯ°æÁ¤º¸ ¼³Á¤ ¿äû/ÀÀ´ä (server -> client)
****************************************************************************/
typedef struct _st_cfg
{
    BYTE    fanTmpr;        // Fan µ¿Àۿµµ(0x00~0x3f)
    BYTE    hetrTmpr;       // Heater µ¿Àۿµµ(0x00~0x3f)
    char    dispOnTm[4];    // Àü±¤ÆÇ °¡µ¿ ½ÃÀ۽ð£(0900)
    char    dispOffTm[4];   // Àü±¤ÆÇ °¡µ¿ Á¾·á½Ã°£(2400)
} st_cfg;

typedef struct _st_ctrl_cfg_req : public st_head
{
    _st_ctrl_cfg_req()
    {
        OpCode = CTRL_CONFIG_REQ;
        Length = sizeof(st_cfg);
        Etx    = VMS_ETX;
    }
    st_cfg  set;
    BYTE    Etx;
} st_ctrl_cfg_req;

typedef st_ack  st_ctrl_cfg_res;

/*
*  ½Ã°£ ¼³Á¤ ¿äû/ÀÀ´ä (server -> client)
****************************************************************************/
typedef struct _st_time
{
    char    time[MAX_SYS_TIME];  // ÇöÀç½Ã°£ Á¤º¸(YYYYMMDDHHMISS)
} st_time;

typedef struct _st_ctrl_time_req : public st_head
{
    _st_ctrl_time_req()
    {
        OpCode = CTRL_TIME_REQ;
        Length = sizeof(st_time);
        Etx    = VMS_ETX;
    }
    st_time set;
    BYTE    Etx;
} st_ctrl_time_req;

typedef st_ack  st_ctrl_time_res;

/*
*  Á¦¾î±â ¸®¼Â
****************************************************************************/
typedef struct _st_reset_req : public st_head
{
    _st_reset_req()
    {
        OpCode = CTRL_TIME_REQ;
        Length = 1;
        Etx    = VMS_ETX;
    }
    BYTE type;  //0x00 : ÇÁ·Î¼¼½º ¸®¼Â 0x01 : Á¦¾î±â ¸®¼Â
    BYTE Etx;
} st_reset_req;

typedef st_ack  st_reset_res;


//---------------------------------------------------------------------------
#pragma pack(pop)
//---------------------------------------------------------------------------

#endif