#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>


#include "iap.h"
#include "carplay.h"
#include "audio_callbacks.h"
#include "video_callbacks.h"
#include "carlink_cp.h"
//#include "DispatchLite.h"
#include "mycommon.h"
#include "ff_sfdisk.h"
#include "carlink_video.h"
#include "carlink_cp_priv.h"

#include "os_adapt.h"
#include <FreeRTOS_POSIX.h>
#include <task.h>
#include "carlink_common.h"
#include "board.h"

#if CARLINK_CP

struct carplay_ctx
{
	struct ICalinkEventCallbacks carlinkEventCB;

	bool   mInitDone;
	bool   mBTConnected;
	bool   mIapReady;
	bool   mCarplayConnected;
	char   mLocalBTMac[6];
	char   mRemoteBTMac[6];
	char   mIp[32];
};

struct carplay_ctx g_cp_handle;
static bool  g_cp_disable = false;


static void carplay_init_parameter();
void start_mdnsd();
void start_mdnsd_posix();
void stop_mdnsd_posix();

static void carplay_notify_event(struct carlink_event *ev, enum CARLINK_EVENT_TYPE type, bool disable_filter)
{
	ev->link_type = CARLINK_CARPLAY_WIRELESS;
	ev->disable_filter = disable_filter;
	ev->type = type;
	carlink_notify_event(ev);
}



static void iap2_link_status(void *ctx, IAP2_LINK_STATUS status){}
static int iap2_write_data(void *ctx, char *buf, int len)
{
	(void)ctx;
	printf("iap2_write_data --------------------------\r\n");
	return carlink_iap_data_write((unsigned char *)buf, len);
}
extern uint32_t tire_front_time;
extern uint32_t tire_rear_time;
extern uint32_t fml_stamp_to_time(uint32_t timep , uint32_t time[]);
static void iap2_msg_time_update(void *ctx, long long time, int zone_offset){
	(void)ctx;
	printf("iap2_msg_time_update time ======================================== %lld , %d\r\n",time,zone_offset);
	uint32_t time_transfer[6];
	uint32_t sum = (uint32_t)time;
	
	tire_rear_time = sum;
	tire_front_time = sum;
	fml_stamp_to_time(sum,time_transfer);
}
static void iap2_msg_gps(void *ctx, unsigned char session, int start){}
static void iap2_msg_gps_gprmc_data_status(void *ctx, int value_a, int value_v, int value_x){}
static void iap2_msg_identify(void *ctx, int type, int ok)
{
	if (ok && !g_link_info->enable_iap_carplay_sess) {
		start_mdnsd_posix();
	}
}
static void iap2_msg_wl_carplay_update(void *ctx, int status){}
//static void iap2_msg_language_update(void *ctx, const char *lang){}

static void carplay_session_started(void *ctx)
{
	struct carlink_event ev = {0};
	carplay_notify_event(&ev, CARLINK_EVENT_MSG_SESSION_CONNECT, 0);
}

static void carplay_session_Stop(void *ctx)
{
	struct carlink_event ev = {0};
	carplay_notify_event(&ev, CARLINK_EVENT_MSG_SESSION_STOP, 0);
}

static void carplay_session_modes_changed(void *ctx, const CarPlayModeState *	inState){}
static void carplay_session_requestUI(void *ctx){}
static void carplay_session_duck_audio(void *ctx, double inDurationSecs, double inVolume){}
static void carplay_session_unduck_audio(void *ctx, double inDurationSecs){}
//static void carplay_session_notify_device_name(void *ctx, const char *name, int len){}

static void carplay_disable_bt_session(void *ctx)
{
	struct carlink_event ev = {0};

	(void)ctx;

	if (g_link_info->disable_carplay_audio)
		return;
	carplay_notify_event(&ev, CARLINK_EVENT_MSG_DISABLE_BT, 0);
}

static int audio_start_callback_impl(void *ctx, int handle, int type, int rate, int bits, int channels)
{
	int ret = -1;

	ret = carlink_cp_audio_start(handle, type, rate, bits, channels);
	return ret;
}
static void audio_stop_callback_impl(void *ctx, int handle, int type)
{
	carlink_cp_audio_stop(handle, type);
}
extern char key_value;

static int video_start_callback_impl(void *ctx)
{
	h264_dec_ctx_init();
    set_carlink_display_state(1);
	key_value = 1;
	return 0;
}

static void video_stop_callback_impl(void *ctx)
{
	key_value = 0;
	set_carlink_display_state(0);
}
static int video_proc_data_callback_impl(void *ctx, char *buf, int len)
{
	video_frame_s* frame = NULL;
	printf("video_proc_data len:%d\r\n", len);

get_retry:
    frame = get_h264_frame_buf();
    if (NULL == frame) {
        printf("h264 frame is empty\r\n");
        vTaskDelay(pdMS_TO_TICKS(10));
        goto get_retry;
        //continue;
    }

    memcpy(frame->cur, buf, len);
    frame->len     = len;

    notify_h264_frame_ready(&frame);
	return 0;
}
static void carplay_viewArea_update_notify(void *ctx, int index){}
static void resetDspMode(void *ctx, int mode){}
static void carplay_msg_notify(void*ctx, const char* buf, int len){}

void test_carplay_modules();

static void start_cp(struct carplay_ctx* pctx)
{
	if (!pctx->mInitDone)
		return;
	//if (pctx->mBTConnected)
	//	return;
	if (!pctx->mIapReady)
		return;

	if (pctx->mCarplayConnected)
		return;

	if (g_cp_disable)
		return;

	g_link_info->enable_iap_carplay_sess = 1;
	g_link_info->is_old_carplay_ver = 0;
	g_link_info->wifi_passwd = (char *)carlink_get_wifi_passwd();
	g_link_info->wifi_ssid   = (char *)carlink_get_wifi_ssid();
	g_link_info->wifi_channel = 36;
	
	{
		char ip[4] = {0};
		carlink_get_ap_ip_addr(ip);
		g_link_info->ip_v4_addr[0] = ip[0];
		g_link_info->ip_v4_addr[1] = ip[1];
		g_link_info->ip_v4_addr[2] = ip[2];
		g_link_info->ip_v4_addr[3] = ip[3];
	}
	
	carplay_start();
}


static void onEventCarplay(void* ctx, const struct carlink_event *ev)
{
	enum CARLINK_EVENT_TYPE type;
	struct carplay_ctx* pctx = (struct carplay_ctx*)ctx;
	
	if (NULL == ev)
		return;
	if (ev->link_type != CARLINK_CARPLAY_WIRELESS && !ev->disable_filter)// skip not aa event
		return;

	type = ev->type;


    switch (type) {
        case -1: {
            break;
        }
		case CARLINK_EVENT_INIT_DONE:
			pctx->mInitDone = true;
			start_cp(pctx);
			break;
        case CARLINK_EVENT_BT_CONNECT: {
            break;
        }
		case CARLINK_EVENT_BT_IAP_READY: {
			pctx->mIapReady = true;
			start_cp(pctx);
            break;
        }
        case CARLINK_EVENT_BT_DISCONNECT: {
			pctx->mIapReady = false;
            break;
        }
        case CARLINK_EVENT_WIFI_CONNECT: {
            break;
        }
		case CARLINK_EVENT_MSG_SESSION_CONNECT: {
			pctx->mCarplayConnected = 1;
            break;
        }
		case CARLINK_EVENT_MSG_SESSION_STOP: {
			if (0 == pctx->mCarplayConnected) {
				printf("carplay connect timeout!\n");
				carlink_restart_bt_wifi();
			} else {
				pctx->mCarplayConnected = 0;
				carlink_bt_open();
			}
            break;
        }
		case CARLINK_EVENT_MSG_DISABLE_BT: {
			carlink_bt_close();
            break;
        }
		
		default:
		break;
    }
}

static void carplay_iap_data_read(void* ctx, const void* buf, int len)
{
	struct carplay_ctx* pctx = (struct carplay_ctx*)ctx;

	if (!pctx->mIapReady)
		return;
	
	iap2_read_data_proc((char*)buf, len);
}


static void  taskInitCarlinkCpProc(void* param)
{
	struct carplay_ctx* pctx = &g_cp_handle;
	struct carlink_event ev = {0};
	int ret  = -1;
#if 0
	carplay_init_parameter();
	carlink_bt_wifi_init();
	//start_mdnsd();
	vTaskDelay(pdMS_TO_TICKS(2000));
	carplay_modules_test();
	vTaskDelete(NULL);
	return;
#endif
	
	(void)param;


	iap2_callbacks iap2_cbs;
	memset((void *)&iap2_cbs, 0, sizeof(iap2_cbs));
	iap2_cbs.iap2_link_status_cb 				= iap2_link_status;
	iap2_cbs.iap2_write_data_cb                 = iap2_write_data;
	iap2_cbs.iap2_msg_time_update_cb 			= iap2_msg_time_update;
	iap2_cbs.iap2_msg_gps_cb 					= iap2_msg_gps;
    iap2_cbs.iap2_msg_gps_gprmc_data_status_cb	= iap2_msg_gps_gprmc_data_status;
	iap2_cbs.iap2_msg_identify_cb 				= iap2_msg_identify;
	iap2_cbs.iap2_msg_wl_carplay_update_cb 		= iap2_msg_wl_carplay_update;
    iap2_cbs.iap2_msg_msg_json_cb           	= carplay_msg_notify;
	iap2_cbs.ctx = (void *)(NULL);
	iap2_register_callbacks(&iap2_cbs);
	
	carplaySessionCbs carplay_cbs;
	memset((void *)&carplay_cbs, 0, sizeof(carplay_cbs));
	carplay_cbs.SessionStarted 				= carplay_session_started;
	carplay_cbs.SessionStop 				= carplay_session_Stop;
	carplay_cbs.SessionModesChanged			= carplay_session_modes_changed;
	carplay_cbs.SessionRequestUI 			= carplay_session_requestUI;
	carplay_cbs.SessionDuckAudio 			= carplay_session_duck_audio;
	carplay_cbs.SessionUnduckAudio 			= carplay_session_unduck_audio;
	carplay_cbs.DisableBtSession 			= carplay_disable_bt_session;
    carplay_cbs.ViewAreaUpdateNotify        = carplay_viewArea_update_notify;
    carplay_cbs.MsgNotify                   = carplay_msg_notify;
	carplay_cbs.ctx 						= (void *)(NULL);
	carplay_register_callbacks((void *)(&carplay_cbs));
	
	video_callbacks_t video_cbs;
	memset((void *)&video_cbs, 0, sizeof(video_cbs));
	video_cbs.video_start_callback 			= video_start_callback_impl;
	video_cbs.video_stop_callback			= video_stop_callback_impl;
	video_cbs.video_proc_data_callback		= video_proc_data_callback_impl;
	video_cbs.ctx							= NULL;
	video_register_callbacks((void *)(&video_cbs));

	audio_callbacks_t audio_cbs;
	memset((void *)&audio_cbs, 0, sizeof(audio_cbs));
	audio_cbs.audio_start_callback 			= audio_start_callback_impl;
	audio_cbs.audio_stop_callback			= audio_stop_callback_impl;
    audio_cbs.audio_reset_DSP_mode_callback = resetDspMode;
	audio_cbs.ctx							= NULL;
	audio_register_callbacks((void *)(&audio_cbs));

	set_carlink_display_info(0, 0, CARLINK_VIDEO_WIDTH, CARLINK_VIDEO_HEIGHT);
	set_carlink_video_info(CARLINK_VIDEO_WIDTH, CARLINK_VIDEO_HEIGHT, 30);
	carplay_init_parameter();
	
	ret = carlink_common_init();
	if (0 != ret) {
		printf("%s:%d failed\n", __func__, __LINE__);
	}

	pctx->carlinkEventCB.onEvent			= onEventCarplay;
	pctx->carlinkEventCB.rfcomm_data_read	= carplay_iap_data_read;
	pctx->carlinkEventCB.cb_ctx 			= (void*)pctx;

	carlink_register_event_callbacks(&pctx->carlinkEventCB);

#if 1
	carlink_bt_wifi_init();
	carplay_init();

	carplay_notify_event(&ev, CARLINK_EVENT_INIT_DONE, 0);
#else
	carplay_modules_test();
#endif

	vTaskDelete(NULL);
}

static void carplay_init_parameter()
{
	g_link_info->link_type 							= CARPLAY_WIRELESS;

	g_link_info->iap2_name = IAP2NAME;
	g_link_info->iap2_modelIdentifier = IAP2MODEID;
	g_link_info->iap2_manfacturer =MANFACTURER;
	g_link_info->iap2_serialnumber = SERIALNUMBER;
	g_link_info->iap2_sw_ver = SWVER;
	g_link_info->iap2_hw_ver = HWVER;
	g_link_info->iap2_vehicleInfo_name = VEHICLENAME;
	g_link_info->iap2_product_uuid = "101375-0068";

	g_link_info->manfacturer = MANFACTURER;
	g_link_info->oem_icon_label = OEMICONLABEL;
	g_link_info->oem_icon_path = OEMICONPATH;
	g_link_info->os_info = OSINFO;
	g_link_info->iOSVersionMin = iOS_VER_MIN;
	g_link_info->limited_ui_elements = LIMITEDUIELEMENTS;
	g_link_info->guuid = DEFAULTUUID;
	g_link_info->devid = DEFAULTDEVID;

	g_link_info->oem_icon_visible = 0;//ISOEMICONVISIBLE;
	g_link_info->limited_ui = ISLIMITEDUI;
	g_link_info->right_hand_driver = ISRIGHTHANDDRIVER;
	g_link_info->night_mode = 0;
	g_link_info->has_knob = HAS_KNOB;
	g_link_info->has_telbutton = 1;
	g_link_info->has_mediabutton = 1;
	g_link_info->has_proxsensor = HAS_PROXSENSOR;
	g_link_info->has_EnhancedReqCarUI = HAS_EnhancedRequestCarUI;
	g_link_info->has_ETCSupported = HAS_ETC;
	g_link_info->HiFiTouch = 1;
	g_link_info->LoFiTouch = 0;

	g_link_info->usb_country_code = kUSBCountryCodeUS;
	g_link_info->tp_verndor_code = kUSBVendorTouchScreen;
	g_link_info->tp_product_code = kUSBProductTouchScreen;
	g_link_info->tel_verndor_code = kUSBVendorTeleButtons;
	g_link_info->tel_product_code = kUSBProductTeleButtons;
	g_link_info->knob_verndor_code = kUSBVendorKnobButtons;
	g_link_info->knob_product_code = kUSBProductKnobButtons;
	g_link_info->proxsensor_verndor_code = kUSBVendorProxSensor;
	g_link_info->proxsensor_product_code = kUSBProductProxSensor;

	g_link_info->width = CARLINK_VIDEO_WIDTH;//pixel
	g_link_info->height = CARLINK_VIDEO_HEIGHT;
	g_link_info->fps = 30;
	g_link_info->screen_width_phy = CARLINK_VIDEO_WIDTH;
	g_link_info->screen_height_phy = CARLINK_VIDEO_HEIGHT;

	g_link_info->icurrent = 1000;
	g_link_info->enable_iap_carplay_sess = 1;
	g_link_info->keychain_path_dir = "/sf";
	g_link_info->is_old_carplay_ver = 0;
	g_link_info->enable_single_ui = 1;
	
	g_link_info->disable_carplay_audio = 1;//1. audio is stream to bt;

	//g_link_info->mfi_ic_addr = 0x22; //cp2.0
	g_link_info->mfi_ic_addr = 0x20; //cp3.0
	g_link_info->mfi_ic_i2c_bus_num = 0;

	g_link_info->area[0].w = CARLINK_VIDEO_WIDTH;
    g_link_info->area[0].h = CARLINK_VIDEO_HEIGHT;
    g_link_info->area[0].x = 0;
    g_link_info->area[0].y = 0;

	g_link_info->area[1].w = 1024;
    g_link_info->area[1].h = 600;
    g_link_info->area[1].x = 0;
    g_link_info->area[1].y = 0;

	g_link_info->view_area_index = 0;
	
}

void carplay_modules_test();
int carlink_cp_init()
{
	xTaskCreate(taskInitCarlinkCpProc, "CpinitThread", 1024 * 32, NULL, configMAX_PRIORITIES / 4, NULL);
	return 0;
}

void carlink_cp_enable(int enable)
{
	if (enable) {
		g_cp_disable = false;
	} else {
		g_cp_disable = true;
	}
}


//int mdnsd_task();
static void  taskMdnsdProc(void* param)
{
	//mdnsd_task();
	vTaskDelete(NULL);
}

void start_mdnsd()
{
	xTaskCreate(taskMdnsdProc, "CpinitThread", 2048 * 4, NULL, 2, NULL);
}

#else
int carlink_cp_init()
{
	return 0;
}

void carlink_cp_enable(int enable)
{
	(void)enable;
}


#endif