#include "app_config.h"
#include "system/includes.h"
#include "os/os_api.h"
#include "event/net_event.h"
#include "wifi/wifi_connect.h"
#include "net/config_network.h"
#include "event/key_event.h"
#include "event/device_event.h"

/*中断列表 */
const struct irq_info irq_info_table[] = {
    //中断号   //优先级0-7   //注册的cpu(0或1)
#ifdef CONFIG_IPMASK_ENABLE
    //不可屏蔽中断方法：支持写flash，但中断函数和调用函数和const要全部放在内部ram
    { IRQ_SOFT5_IDX,      6,   0    }, //此中断强制注册到cpu0
    { IRQ_SOFT4_IDX,      6,   1    }, //此中断强制注册到cpu1
#if 0 //如下，SPI1使用不可屏蔽中断设置,优先级固定7
    { IRQ_SPI1_IDX,      7,   1    },//中断强制注册到cpu0/1
#endif
#endif
#if CPU_CORE_NUM == 1
    { IRQ_SOFT5_IDX,      7,   0    }, //此中断强制注册到cpu0
    { IRQ_SOFT4_IDX,      7,   1    }, //此中断强制注册到cpu1
    { -2,     			-2,   -2   },//如果加入了该行, 那么只有该行之前的中断注册到对应核, 其他所有中断强制注册到CPU0
#endif
    { -1,     -1,   -1    },
};

/*任务列表 */
const struct task_info task_info_table[] = {
    {"init",                30,     512,   256   },
    {"app_core",            15,     1024,   256   },
    {"sys_event",           29,      512,   0     },
    {"systimer",            14,      256,   0     },
    {"sys_timer",            9,      512,   64    },
    {"mp3_encoder",         13,      768,   0     },
    {"jla_encoder",         13,      768,   0     },
    {"audio_server",        16,      512,   64    },
    {"audio_mix",           28,      512,   0     },
    {"audio_decoder",       30,     1024,   64    },
    {"audio_encoder",       12,      384,   64    },
    {"speex_encoder",       10,     1024,   0     },
    {"opus_encoder",        10,     1536,   0     },
    {"ogg_encoder",         10,     1536,   0     },
    {"vir_dev_task",        13,      256,   0     },
    {"wechat_task",         18,     2048,   64    },
    {"amr_encoder",         16,     1024,   0     },
    {"cvsd_encoder",        13,      512,   0     },
    {"vad_encoder",         16,     1024,   0     },
    {"aec_encoder",         13,     1024,   0     },
    {"dns_encoder",         13,      512,   0     },
    {"adpcm_encoder",       13,      512,   0     },
    {"msbc_encoder",        13,      256,   0     },
    {"echo_deal",           11,     1024,   32    },
    {"sbc_encoder",         13,      512,   0     },
    {"usb_server",          20,     1024,   64    },
#if CPU_CORE_NUM > 1
    {"#C0usb_msd0",          1,      512,   128   },
#else
    {"usb_msd0",             1,      512,   128   },
#endif
    {"usb_msd1",             1,      512,   128   },
    {"uac_sync",            20,      512,   0     },
    {"uac_play",             7,      768,   0     },
    {"uac_record",           7,      768,   32    },
    {"uda_main",             2,     7000,   0     },
#ifdef CONFIG_BT_ENABLE
#if CPU_CORE_NUM > 1
    {"#C0btencry",          16,      512,   128   },
    {"#C0btctrler",         19,      512,   384   },
    {"#C0btstack",          18,      1024,  384   },
#else
    {"btencry",             14,      512,   128   },
    {"btctrler",            19,      512,   384   },
    {"btstack",             18,      768,   384   },
#endif
#endif

    {"tcpip_thread",        16,     800,  	 0},
#ifdef CONFIG_WIFI_ENABLE
    {"tasklet",             10,     1400,    0},//通过调节任务优先级平衡WIFI收发占据总CPU的比重
    {"RtmpMlmeTask",        17,     700,  	 0},
    {"RtmpCmdQTask",        17,     300,   	 0},
    {"wl_rx_irq_thread",     5,     256,  	 0},
#endif

#ifdef CONFIG_UI_ENABLE
    {"ui",                  21,      768,   256   },
    {"lcd_task_0",			9,	    1024,   32    },
    {"lcd_task_1",		    9,	    1024,   32    },
    {"te_task",		       10,	    1024,	32    },
#endif
    {"update",              21,      512,   32    },
    {"dw_update",           21,      512,   32    },
    {"iperf_test",          15,     1024,   0     },
    {"ai_server",			15,		1024,	64    },
    {"asr_server",			15,		1024,	64    },
    {"wake-on-voice",		7,		1024,	0     },
    {"resample_task",		8,		1024,	0     },
    {"video_server",        26,      800,   1024  },
    {"vpkg_server",         26,      512,   512   },
    {"jpg_dec",             27,     1024,   32    },
    {"jpg_spec_enc",        27,     1024,   32    },
    {"dynamic_huffman0",    15,      256,   32    },
    {"video0_rec0",         25,      512,   512   },
    {"video0_rec1",         24,      512,   512   },
    {"video1_rec0",         25,      512,   512   },
    {"video1_rec1",         24,      512,   512   },
    {"video2_rec0",         25,      512,   512   },
    {"video2_rec1",         24,      512,   512   },
    {"audio_rec0",          22,      256,   256   },
    {"audio_rec1",          19,      256,   256   },
    {"avi0",                29,      320,   64    },
    {"avi1",                29,      320,   64    },
    {"avi2",                29,      320,   64    },

    {"ctp_server",          26,      600,   64    },
    {"net_video_server",    16,      256,   64    },
    {"net_avi0",            24,      600,   0     },
    {"net_avi1",            24,      600,   0     },
    {"net_avi2",            24,      600,   0     },
    {"stream_avi0",         18,      600,   0     },
    {"stream_avi1",         18,      600,   0     },
    {"stream_avi2",         18,      600,   0     },
    {"video_dec_server",    27,     1024,   1024  },
    {"vunpkg_server",       23,     1024,   128   },
    {"yuv_task",            22,     1024,   128   },
    {"wyuv_task",           22,     1024,   128   },

    {0, 0, 0, 0, 0},
};

static int app_demo_state_machine(struct application *app, enum app_state state, struct intent *it)
{
    return 0;
}

static int doubao_key_click(struct key_event *key)
{
    /* printf("key->value%d\n",key->value); */
    switch (key->value) {
    case KEY_OK:
        printf("app_event_handler[in %s task]  SYS_KEY_EVENT %d \r\n", os_current_task(), key->value);
        extern OS_SEM voice_start_sem;
        os_sem_set(&voice_start_sem,0);
        os_sem_post(&voice_start_sem);
        break;
    default:
        break;
    }

    return false;
}

static void bt_net_config(void)
{
    printf("%s   %d\n", __func__, __LINE__);

#ifdef CONFIG_ASSIGN_MACADDR_ENABLE
    cancel_server_assign_macaddr();
#endif


    if (!is_in_config_network_state()) {
        sys_power_auto_shutdown_pause();

        config_network_start();
    } else {

        config_network_stop();
        wifi_return_sta_mode();
        sys_power_auto_shutdown_resume();
    }

}

static int bt_net_config_key_click(struct key_event *key)
{
    /* printf("key->value%d\n",key->value); */
    switch (key->value) {
    case KEY_OK:
#ifdef CONFIG_NET_ENABLE
        puts("switch_net_config\n");
        bt_net_config();
#endif
        break;
    default:
        break;
    }

    return false;
}

static int doubao_key_longclick(struct key_event *key)
{
    /* printf("key->value%d\n",key->value); */
    switch (key->value) {
    case KEY_OK:
        printf("app_event_handler[in %s task]  SYS_KEY_EVENT %d \r\n", os_current_task(), key->value);
        extern OS_SEM voice_pause_sem;
        extern OS_SEM listen_close_sem;
        os_sem_set(&voice_pause_sem,0);
        os_sem_post(&voice_pause_sem);
        os_sem_set(&listen_close_sem,0);
        os_sem_post(&listen_close_sem);
        break;
    default:
        break;
    }

    return false;
}

static int doubao_key_event_handler(struct key_event *key)
{
    int ret = false;

    switch (key->action) {

    case KEY_EVENT_CLICK:
        ret = doubao_key_click(key);
        break;
    case KEY_EVENT_DOUBLE_CLICK:
        ret = bt_net_config_key_click(key);
        break;
    case KEY_EVENT_LONG:
        ret = doubao_key_longclick(key);
        break;
    default:
        break;
    }

    return ret;
}

static int app_demo_event_handler(struct application *app, struct sys_event *sys_event)
{
    switch (sys_event->type) {
    case SYS_NET_EVENT:
#ifdef USE_DEMO_WIFI_TEST
        struct net_event *net_event = (struct net_event *)sys_event->payload;
        if (!ASCII_StrCmp(net_event->arg, "net", 4)) {
            switch (net_event->event) {
            case NET_CONNECT_TIMEOUT_NOT_FOUND_SSID:
                puts("app_demo_event_handler recv NET_CONNECT_TIMEOUT_NOT_FOUND_SSID \r\n");
                break;
            case NET_CONNECT_ASSOCIAT_FAIL:
                puts("app_demo_event_handler recv NET_CONNECT_ASSOCIAT_FAIL \r\n");
                break;
            case NET_EVENT_SMP_CFG_FIRST:
                puts("app_demo_event_handler recv NET_EVENT_SMP_CFG_FIRST \r\n");
                break;
            case NET_EVENT_SMP_CFG_FINISH:
                puts("app_demo_event_handler recv NET_EVENT_SMP_CFG_FINISH \r\n");
                if (is_in_config_network_state()) {
                    config_network_stop();
                }
                config_network_connect();
                break;
            case NET_EVENT_CONNECTED:
                puts("app_demo_event_handler recv NET_EVENT_CONNECTED \r\n");
                extern void config_network_broadcast(void);
                config_network_broadcast();
                break;
            case NET_EVENT_DISCONNECTED:
                puts("app_demo_event_handler recv NET_EVENT_DISCONNECTED \r\n");
                break;
            case NET_EVENT_SMP_CFG_TIMEOUT:
                puts("app_demo_event_handler recv NET_EVENT_SMP_CFG_TIMEOUT \r\n");
                break;
            case NET_SMP_CFG_COMPLETED:
                puts("app_demo_event_handler recv NET_SMP_CFG_COMPLETED \r\n");
#ifdef CONFIG_AIRKISS_NET_CFG
                wifi_smp_set_ssid_pwd();
#endif
                break;
            case NET_EVENT_DISCONNECTED_AND_REQ_CONNECT:
                puts("app_demo_event_handler recv NET_EVENT_DISCONNECTED_AND_REQ_CONNECT \r\n");
//extern void sys_power_auto_shutdown_pause();
                wifi_return_sta_mode();
                break;
            case NET_NTP_GET_TIME_SUCC:	//NTP获取成功事件返回
                break;
            default:
                break;
            }
        }
#endif //USE_DEMO_WIFI_TEST
    case SYS_KEY_EVENT:
        printf("%s   %d\n", __func__, __LINE__);
        doubao_key_event_handler((struct key_event *)sys_event->payload);
//    case SYS_BT_EVENT:
//        extern int ble_demo_bt_event_handler(struct sys_event * event);
//        ble_demo_bt_event_handler(sys_event);
//        break;
    default:
        return false;
    }
}

static const struct application_operation app_demo_ops = {
    .state_machine  = app_demo_state_machine,
    .event_handler 	= app_demo_event_handler,
};

REGISTER_APPLICATION(app_demo) = {
    .name 	= "app_demo",
    .ops 	= &app_demo_ops,
    .state  = APP_STA_DESTROY,
};

#if 0
void app_default_event_handler(struct sys_event *event)
{
    switch (event->type) {
    case SYS_KEY_EVENT:
#ifdef UI_MASS_PRODUCTION
        extern int raw_key_event_handler(struct key_event * key);
        raw_key_event_handler((struct key_event *)event->payload);
#endif
        break;
    case SYS_TOUCH_EVENT:
        break;
    case SYS_DEVICE_EVENT:
        break;
    case SYS_NET_EVENT:
        break;
    case SYS_BT_EVENT:
        break;
    default:
        ASSERT(0, "unknow event type: %s\n", __func__);
        break;
    }
}
#endif

/*
 * 应用程序主函数
 */
void app_main()
{
#ifdef CONFIG_CXX_SUPPORT
    //注意：使用时也可以不放置在这里调用，但必须在使用c++前进行调用初始化c++环境
    void cpp_run_init(void);
    cpp_run_init();
#endif
    printf("\r\n\r\n\r\n\r\n 1--------------- app_main run %s ---------------\r\n\r\n\r\n\r\n\r\n", __TIME__);

    struct intent it;
    init_intent(&it);
    it.name = "app_demo";
    it.action = ACTION_DO_NOTHING;
    start_app(&it);

    extern void bt_ble_module_init(void);
    bt_ble_module_init();

    key_event_enable(); //针对按键事件,需要先使能开关
}