/***************************************************************************************
 *
 *  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
 *
 *  By downloading, copying, installing or using the software you agree to this license.
 *  If you do not agree to this license, do not download, install, 
 *  copy or use the software.
 *
 *  Copyright (C) 2014-2024, Happytimesoft Corporation, all rights reserved.
 *
 *  Redistribution and use in binary forms, with or without modification, are permitted.
 *
 *  Unless required by applicable law or agreed to in writing, software distributed 
 *  under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 *  CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
 *  language governing permissions and limitations under the License.
 *
****************************************************************************************/

#include "sys_inc.h"
#include "rtsp_cln.h"
#include "hqueue.h"
#include "http.h"
#include "http_parse.h"
#include "video_decoder.h"


/**********************************************************/
HQUEUE    * g_queue;
int		 	g_flag = 0;
pthread_t	g_tid = 0;

/**********************************************************/

typedef struct
{
    CRtspClient     rtsp;
    CVideoDecoder   decoder;
    BOOL            decoder_init;
} MyPlayer;

typedef struct
{
	int 	      event;
	MyPlayer    * player;
} EVENT_PARAMS;

/**********************************************************/

void video_decoder_cb(AVFrame * frame, void * userdata)
{
    MyPlayer * p_player = (MyPlayer *) userdata;

    
}

/**
 * @desc : rtsp notify callback
 *
 * @params :
 *  event : event type
 *  puser : user parameter
 */
int rtsp_notify_cb(int event, void * puser)
{
    printf("%s, event = %d\r\n", __FUNCTION__, event);

    MyPlayer * p_player = (MyPlayer *) puser;
    CRtspClient * p_rtsp = &p_player->rtsp;

    if (RTSP_EVE_CONNSUCC == event)
    {
        int vcodec = p_rtsp->video_codec();
        if (vcodec != VIDEO_CODEC_NONE)
        {
            char codec_str[20] = {'\0'};
            
            switch (vcodec)
            {
            case VIDEO_CODEC_H264:
                strcpy(codec_str, "H264");
                break;

            case VIDEO_CODEC_H265:
                strcpy(codec_str, "H265");
                break;

            case VIDEO_CODEC_MP4:
                strcpy(codec_str, "MP4");
                break;

            case VIDEO_CODEC_JPEG:
                strcpy(codec_str, "JPEG");
                break;    
            }

            printf("video codec is %s\r\n", codec_str);
        }

        int acodec = p_rtsp->audio_codec();
        if (acodec != AUDIO_CODEC_NONE)
        {
            char codec_str[20] = {'\0'};
            
            switch (acodec)
            {
            case AUDIO_CODEC_G711A:
                strcpy(codec_str, "G711A");
                break;

            case AUDIO_CODEC_G711U:
                strcpy(codec_str, "G711U");
                break;

            case AUDIO_CODEC_G722:
                strcpy(codec_str, "G722");
                break;

            case AUDIO_CODEC_G726:
                strcpy(codec_str, "G726");
                break;

            case AUDIO_CODEC_OPUS:
                strcpy(codec_str, "OPUS");
                break;

            case AUDIO_CODEC_AAC:
                strcpy(codec_str, "AAC");
                break;    
            }

            printf("audio codec is %s\r\n", codec_str);
            printf("audio sample rate is %d\r\n", p_rtsp->get_audio_samplerate());
            printf("audio channels is %d\r\n", p_rtsp->get_audio_channels());
        }
    }

	EVENT_PARAMS params;

	params.event = event;
	params.player = p_player;

    if (!hqBufPut(g_queue, (char *) &params))
    {
    	printf("hqBufPut failed\r\n");
    }
    
    return 0;
}

/**
 * @desc : rtsp audio data callback
 *
 * @params :
 *  pdata : audio data buffer
 *  len : audio data buffer length
 *  ts : timestamp
 *  seq : sequential
 *  puser : user parameter
 */
int rtsp_audio_cb(uint8 * pdata, int len, uint32 ts, uint16 seq, void * puser)
{
    MyPlayer * p_player = (MyPlayer *) puser;
    
    printf("%s, len = %d, ts = %u, seq = %d\r\n", __FUNCTION__, len, ts, seq);
    
    return 0;
}

/**
 * @desc : rtsp video data callback
 *
 * @params :
 *  pdata : video data buffer
 *  len : video data buffer length
 *  ts : timestamp
 *  seq : sequential
 *  puser : user parameter
 */
int rtsp_video_cb(uint8 * pdata, int len, uint32 ts, uint16 seq, void * puser)
{
    MyPlayer * p_player = (MyPlayer *) puser;
    CRtspClient * p_rtsp = &p_player->rtsp;
    CVideoDecoder * p_decoder = &p_player->decoder;
    
    printf("%s, len = %d, ts = %u, seq = %d\r\n", __FUNCTION__, len, ts, seq);

    if (!p_player->decoder_init)
    {
        p_player->decoder_init = p_decoder->init(p_rtsp->video_codec());
        p_decoder->setCallback(video_decoder_cb, p_player);
    }

    if (p_player->decoder_init)
    {
        p_decoder->decode(pdata, len, ts);
    }
    
    return 0;
}

/**
 * @desc : RTCP raw data callback
 *
 * @params :
 *  pdata : RTCP raw data
 *  len : data length
 *  type : AV_VIDEO_CH, AV_AUDIO_CH, AV_METADATA_CH, AV_BACK_CH
 *  puser : user parameter
 */
int rtsp_rtcp_cb(uint8 * pdata, int len, int type, void * puser)
{
    MyPlayer * p_player = (MyPlayer *) puser;
    
    printf("%s, len = %d, type = %d\r\n", __FUNCTION__, len, type);
    
    return 0;
}

/**
 * @desc : rtsp meta data callback
 *
 * @params :
 *  pdata : meta data buffer
 *  len : meta data buffer length
 *  ts : timestamp
 *  seq : sequential
 *  puser : user parameter
 */
int rtsp_metadata_cb(uint8 * pdata, int len, uint32 ts, uint16 seq, void * puser)
{
    MyPlayer * p_player = (MyPlayer *) puser;
    
	printf("%s, len = %d, ts = %u, seq = %d\r\n", __FUNCTION__, len, ts, seq);
    
    return 0;
}

void rtsp_setup(MyPlayer * player)
{
    CRtspClient * p_rtsp = &player->rtsp;
    
    p_rtsp->set_notify_cb(rtsp_notify_cb, player);
    p_rtsp->set_audio_cb(rtsp_audio_cb);
    p_rtsp->set_video_cb(rtsp_video_cb);
    p_rtsp->set_rtcp_cb(rtsp_rtcp_cb);
#ifdef METADATA    
    p_rtsp->set_metadata_cb(rtsp_metadata_cb);
#endif
    // p_rtsp->set_rtp_over_udp(1);    // rtp over udp
    // p_rtsp->set_rtp_multicast(1);   // force multicast rtp via rtsp
#ifdef BACKCHANNEL
    // p_rtsp->set_bc_flag(1);         // enable audio backchannel
    // p_rtsp->set_bc_data_flag(1);    // enable send audio data
#endif
#ifdef REPLAY
    // p_rtsp->set_replay_flag(1);     // enable replay
    // p_rtsp->set_replay_range(time(NULL) - 3600, time(NULL)); // set the replay timestamp range
#endif
#ifdef OVER_HTTP
    // p_rtsp->set_rtsp_over_http(1, 80); 	// rtsp over http
#endif
#ifdef OVER_WEBSOCKET
    // p_rtsp->set_rtsp_over_ws(1, 80); 	// rtsp over websocket
#endif

    p_rtsp->set_rx_timeout(10);        // No data within 10s, receiving timeout
    // p_rtsp->set_channel(AV_VIDEO_CH, 0);     // not setup video channel
    // p_rtsp->set_channel(AV_AUDIO_CH, 0);     // not setup audio channel
    // p_rtsp->set_channel(AV_METADATA_CH, 0);  // not setup metadata channel
    // p_rtsp->set_channel(AV_BACK_CH, 0);      // not setup audio back channel
}

void rtsp_reconn(MyPlayer * p_player)
{
	char url[256], user[64], pass[64];
	CRtspClient * p_rtsp = &p_player->rtsp;

	strcpy(url, p_rtsp->get_url());
	strcpy(user, p_rtsp->get_user());
	strcpy(pass, p_rtsp->get_pass());

	printf("rtsp_reconn, url = %s, user = %s, pass = %s\r\n", url, user, pass);

	p_rtsp->rtsp_close();

	rtsp_setup(p_player);

	p_rtsp->rtsp_start(url, user, pass);
}

void * rtsp_notify_handler(void * argv)
{
	EVENT_PARAMS params;
	
	while (g_flag)
	{
		if (hqBufGet(g_queue, (char *) &params))
		{
			if (params.event == -1 || params.player == NULL)
			{
				break;
			}

			if (RTSP_EVE_STOPPED == params.event || 
			    RTSP_EVE_CONNFAIL == params.event || 
			    RTSP_EVE_NOSIGNAL == params.event || 
			    RTSP_EVE_NODATA == params.event)
			{
				rtsp_reconn(params.player);
				
				usleep(100*1000);
			}
		}
	}

	g_tid = 0;

	printf("%s exit\r\n", __FUNCTION__);

	return NULL;
}

#define RTSP_CLN_NUM    1

int main(int argc, char * argv[])
{
	if (argc < 2)
	{
		printf("usage: %s url {user} {pass}\r\n", argv[0]);
		return  -1;
	}

	log_init("rtsptest.log");
	log_set_level(HT_LOG_DBG);

	network_init();

    // allocate system BUFFER and rtsp parser BUFFER
	sys_buf_init(RTSP_CLN_NUM * 8);
	rtsp_parse_buf_init(RTSP_CLN_NUM * 8);

#if defined(OVER_HTTP) || defined(OVER_WEBSOCKET)
    // allocate http message parser BUFFER
    http_msg_buf_init(RTSP_CLN_NUM * 8);
#endif

    // create event queue
	g_queue = hqCreate(RTSP_CLN_NUM * 4, sizeof(EVENT_PARAMS), HQ_PUT_WAIT | HQ_GET_WAIT);
	if (NULL == g_queue)
	{
		printf("create queue failed\r\n");
		return -1;
	}

    // create event handler thread
	g_flag = 1;
	g_tid = sys_os_create_thread((void *)rtsp_notify_handler, NULL);
	if (g_tid == 0)
	{
		printf("create rtsp notify handler thread failed\r\n");
		return -1;
	}

    MyPlayer * player = new MyPlayer[RTSP_CLN_NUM];

    for (int i = 0; i < RTSP_CLN_NUM; i++)
    {
        player->decoder_init = FALSE;
        
        rtsp_setup(&player[i]);

    	char * p_user = NULL;
    	char * p_pass = NULL;

    	if (argc >= 3)
    	{
    		p_user = argv[2];
    	}

    	if (argc >= 4)
    	{
    		p_pass = argv[3];
    	}
    	
    	BOOL ret = player[i].rtsp.rtsp_start(argv[1], p_user, p_pass);
    	
    	printf("rtsp %d start ret = %d\r\n", i, ret);

    	usleep(100 * 1000);
    }
    
	for (;;)
	{
		if (getchar() == 'q')
		{
			break;
		}
		
		usleep(1000*1000); // 1s
	}

    for (int i = 0; i < RTSP_CLN_NUM; i++)
    {
	    player[i].rtsp.rtsp_close();
	}

	delete[] player;

	g_flag = 0;

	EVENT_PARAMS params;

	params.event = -1;
	params.player = NULL;
	
	hqBufPut(g_queue, (char *) &params);

	// waiting for event handler thread to exit
	while (g_tid)
	{
		usleep(10*1000);
	}

	hqDelete(g_queue);
	g_queue = NULL;

    // free memory resources
	rtsp_parse_buf_deinit();
	sys_buf_deinit();

#if defined(OVER_HTTP) || defined(OVER_WEBSOCKET)
    http_msg_buf_deinit();
#endif

    // close log
    log_close();
		
	return 0;
}