/*----------------------------------------------------------------------------
 * Copyright (c) TJD Technologies Co., Ltd. 2024. All rights reserved.
 *
 * Description: 
 *
 * Author: huangshuyi
 *
 * Create: 2024-8
 *--------------------------------------------------------------------------*/
//brandy-native-tjd -nhso -release

#include "TjdUiAppOnlineWfVideoPage.h"
#include "wearable_log.h"
#include "common/image_cache_manager.h"
#include <time.h>
#include <unordered_map>
#include "gfx_utils/image_info.h"
#include "gfx_utils/heap_base.h"
#include "TjdUiImageIds.h"
#include "power_display_service.h"
#include "TjdUiMemManage.h"
#include "sys_config.h"
#include "rtc_api.h"
#include "product_evb4_standard.h"
#include "common/key_code.h"
#include "common/image_cache_manager.h"
#include "sql_setting.h"


using namespace OHOS;
using namespace OHOS::Media;
using OHOS::Media::Player;

namespace TJD {


#define ENABLE_PRINT_INFO 1
#if ENABLE_PRINT_INFO
#define static_print_info(...)      sys_ui_log_i(__VA_ARGS__)	//一般信息打印宏控制
#define static_print_warn(...)      sys_ui_log_w(__VA_ARGS__)	//警告信息打印一般常开
#define static_print_error(...)     sys_ui_log_e(__VA_ARGS__)	//错误信息打印一般常开
#define static_print_debug(...)     sys_ui_log_d(__VA_ARGS__)
#else
#define static_print_info(...)
#define static_print_warn(...)
#define static_print_error(...)
#define static_print_debug(...)
#endif
static constexpr int16_t VIDEO_WIDTH = HORIZONTAL_RESOLUTION;
static constexpr int16_t VIDEO_HEIGHT = VERTICAL_RESOLUTION;
static constexpr int16_t STRIDE_ALIGNMENT_VALUE = 128;
static constexpr int16_t BUFFER_QUEUE_SIZE = 3;
static constexpr int16_t JPEG_HEIGHT_DIVISOR = 2;
static constexpr int16_t JPEG_WIDTH_BYTE_ALIGNMENT = 128;
static constexpr int16_t JPEG_HEIGHT_BYTE_ALIGNMENT = 16;
static const int32_t WAIT_VIDEO_EXIT_SUCCESS_MS = 10;
static const int32_t REQUEST_BUFFER_REPET_COUNT = 10;
static const uint32_t WAIT_VIDEO_EXIT_MAX_RETRY_COUNT = 100;
static AudioManager &g_amInstance = AudioManager::GetInstance();

#define MEDIA_OK 0
#define MEDIA_INVALID_PARAM (-1)
#define MEDIA_INIT_FAIL (-2)
#define MEDIA_ERR (-3)
#define MEDIA_PERMISSION_DENIED (-4)


TjdUiAppOnlineWfVideoPage::TjdUiAppOnlineWfVideoPage(UIView* parent, std::string uri, std::string previewPath) : Parent_(parent),uri_(uri),previewPath_(previewPath)
{
    InitView();
}

TjdUiAppOnlineWfVideoPage::~TjdUiAppOnlineWfVideoPage()
{
    if (videoPlay_ != nullptr) {
        delete videoPlay_;
        videoPlay_ = nullptr;
        static_print_debug("delete videoPlay\n");
    }
    ImageCacheManager::GetInstance().UnloadSingleRes(previewPath_.c_str());
}

UIView *TjdUiAppOnlineWfVideoPage::GetView(void)
{
    return surfaceView_;
}

bool TjdUiAppOnlineWfVideoPage::InitView(void)
{
    surfaceView_ = new UILiteSurfaceView();
    if (surfaceView_ == nullptr) {
        GRAPHIC_LOGE("surfaceView is nullptr\n");
        return false;
    }
    UIViewGroup *p = (UIViewGroup *)Parent_;
    p->Add(surfaceView_);
    ImageInfo* imgInfo;
    imgInfo = ImageCacheManager::GetInstance().LoadSingleRes(previewPath_.c_str());
    surfaceView_->SetPreview(imgInfo);
    colorKey_.full = 0xff202020;
    surfaceView_->SetViewId("sur");
    surfaceView_->SetPosition(0, 0, VIDEO_WIDTH, VIDEO_HEIGHT);
    surfaceView_->SetStyle(STYLE_BACKGROUND_COLOR, Color::Black().full);
    surfaceView_->SetSurfaceColorkey(colorKey_);

    Surface *surface = surfaceView_->GetSurface();
    surface->SetStrideAlignment(STRIDE_ALIGNMENT_VALUE);
    surface->SetWidthAndHeight(VIDEO_WIDTH, VIDEO_HEIGHT);
    surface->SetQueueSize(BUFFER_QUEUE_SIZE);
    surface->SetFormat(PIXEL_FMT_YCBCR_420_SP);

    // jpeg decoder output buffer size calculation formula
    int32_t ySize = ALIGN_BYTE(VIDEO_WIDTH, JPEG_WIDTH_BYTE_ALIGNMENT) * VIDEO_HEIGHT;
    int32_t uvSize = ALIGN_BYTE(VIDEO_WIDTH, JPEG_WIDTH_BYTE_ALIGNMENT) *
                     ALIGN_BYTE(VIDEO_HEIGHT, JPEG_HEIGHT_BYTE_ALIGNMENT) / JPEG_HEIGHT_DIVISOR;
    int32_t bufferSize = ySize + uvSize;
    surface->SetSize(bufferSize);
    if (videoPlay_ == nullptr) {
        videoPlay_ = new TjdUiVideoCommon(surface, uri_, false);
        videoPlay_->SetSyncExitMode(true);
    }
    //videoPlay_->StartVideoPlay();
    return true;
}

static bool InitPlayerResources(TjdUiVideoCommon *videoPlay)
{
    videoPlay->mutex_ = MediaMutexCreate(nullptr);
    if (videoPlay->mutex_ == nullptr) {
        static_print_error("create mutex failed\n");
        return false;
    }
    videoPlay->cond_ = MediaThreadCondCreate();
    if (videoPlay->cond_ == nullptr) {
        static_print_error("create thread cond failed\n");
        MediaMutexDestroy(&videoPlay->mutex_);
        return false;
    }
    shared_ptr<Player> player = std::make_shared<Player>();
    if (player == nullptr || player.get() == nullptr) {
        static_print_error("player is nullptr\n");
        MediaMutexDestroy(&videoPlay->mutex_);
        MediaThreadCondDestroy(&videoPlay->cond_);
        return false;
    }

    videoPlay->player_ = player;

    videoPlay->isPlaybackCompleted_ = false;
    videoPlay->playError_ = false;
    videoPlay->interruptHintStop_ = false;
    return true;
}

static void DeinitPlayerResources(TjdUiVideoCommon *videoPlay)
{
    (void)videoPlay->player_.reset();
    videoPlay->isExited_ = true;
    videoPlay->isEntered_ = false;
    (void)MediaThreadCondDestroy(&videoPlay->cond_);
    (void)MediaMutexDestroy(&videoPlay->mutex_);
}

static int32_t VideoPlay(TjdUiVideoCommon *videoPlay)
{
    std::shared_ptr<PlayerCallback> callback = std::make_shared<TjdUiAppOnlineWfVideoPage::VideoPlayCallback>(videoPlay);
    if (callback == nullptr || callback.get() == nullptr) {
        static_print_error("AlbumVideoPlayer::%s: callback is nullptr", __func__);
        return MEDIA_ERR;
    }
    videoPlay->player_->SetPlayerCallback(callback);
    int32_t ret = videoPlay->player_->Play();
    if (ret != 0) {
        static_print_error("play failed\n");
        (void)videoPlay->player_->Reset();
        (void)videoPlay->player_->Release();
        return MEDIA_ERR;
    }
    videoPlay->player_->EnableSingleLooping(videoPlay->isLoop_);
    MediaMutexLock(videoPlay->mutex_);
    videoPlay->isPlayed_ = true;
    /*若有自定义组件在开始时需要改变，在这里修改*/
    //videoPlay->button_->SetText("Pause");
    while (!videoPlay->isPlaybackCompleted_ && !videoPlay->isPlaybackStopped_ && !videoPlay->interruptHintStop_ &&
           !videoPlay->playError_) {
        MediaThreadCondWait(videoPlay->cond_, videoPlay->mutex_);
    }
    MediaMutexUnLock(videoPlay->mutex_);
    return 0;
}

static void VideoStopAndExit(TjdUiVideoCommon *videoPlay)
{
    MediaMutexLock(videoPlay->mutex_);
    int32_t ret = videoPlay->player_->Stop();
    if (ret != 0) {
        static_print_error("stop failed");
    }
    ret = videoPlay->player_->Reset();
    if (ret != 0) {
        static_print_error("reset failed");
    }
    videoPlay->isPlaybackCompleted_ = false;
    videoPlay->isPlayed_ = false;
    videoPlay->isPause_ = false;
    /*若有自定义组件需要结束时改变，在这里在修改*/
    //videoPlay->button_->SetText("Play");
    MediaMutexUnLock(videoPlay->mutex_);
}

static int32_t ReleasePlayer(TjdUiVideoCommon *videoPlay)
{
    (void)videoPlay->player_->Reset();
    (void)videoPlay->player_->Release();
    (void)DeinitPlayerResources(videoPlay);
    return MEDIA_ERR;
}

static void SendBackgroundFrame(TjdUiVideoCommon *videoPlay)
{
    int32_t ret = videoPlay->player_->Release();
    if (ret != 0) {
        static_print_error("release failed");
    }
    if (!videoPlay->needSendBackgroundFrame_) {
        (void)DeinitPlayerResources(videoPlay);
        return;
    }
    SurfaceBuffer *buf = nullptr;
    int32_t requestCount = 0;
    while ((buf = videoPlay->surface_->RequestBuffer()) == nullptr) {
        if (requestCount++ > REQUEST_BUFFER_REPET_COUNT) {
            static_print_error("request the last buffer failed");
            break;
        }
        LiteSurface *liteSurface = dynamic_cast<LiteSurface *>(videoPlay->surface_);
        if (liteSurface == nullptr) {
            static_print_error("liteSurface is null!");
            break;
        }
        videoPlay->surface_->CancelBuffer(liteSurface->GetBackBuf());
    }
    if (buf != nullptr) {
        buf->format = PIXEL_FMT_BUTT;
        videoPlay->surface_->FlushBuffer(buf);
    }
    (void)DeinitPlayerResources(videoPlay);
}

static Source GetVideoPlaySource(TjdUiVideoCommon *videoPlay)
{
    Source source;
    if (!videoPlay->uri_.empty()) {
        std::map<std::string, std::string> header;
        source = Source(videoPlay->uri_, header);
    } else if (videoPlay->fd_ > 0) {
        if (videoPlay->isLoop_) {
            int32_t ret = lseek(videoPlay->fd_, 0, SEEK_SET);
            if (ret == -1) {
                static_print_error("lseek[fd = %d] file fail, error[%d]\n", videoPlay->fd_, errno);
                return source;
            }
        }
        source = Source(videoPlay->fd_, videoPlay->offset_, 0);
    }
    return source;
}

static int32_t SetAudioSessionIdAndStreamType(TjdUiVideoCommon *videoPlay)
{
    int32_t ret = MEDIA_OK;
    if (!videoPlay->isPureVideo_) {
        ret = videoPlay->player_->SetAudioSessionId(videoPlay->sessionId_);
        if (ret != MEDIA_OK) {
            static_print_error("AlbumVideoPlayer::%s: set audio sessionId failed", __func__);
            return ret;
        }
        ret = videoPlay->player_->SetAudioStreamType(AUDIO_STREAM_FITNESS_VIDEO);
        if (ret != MEDIA_OK) {
            static_print_error("AlbumVideoPlayer::%s: set audio stream type failed", __func__);
            return ret;
        }
    }
    return ret;
}

static int32_t RunVideoPlay(TjdUiVideoCommon *videoPlay)
{
    bool success = InitPlayerResources(videoPlay);
    if (!success) {
        static_print_error("init player resources failed\n");
        return MEDIA_ERR;
    }
    int32_t ret = 0;
    char filePath[PATH_MAX];
    if (realpath(videoPlay->uri_.c_str(), filePath) == nullptr) {
        static_print_error("no %s resource", videoPlay->uri_.c_str());
        return MEDIA_ERR;
    }
    Source source = GetVideoPlaySource(videoPlay);
    ret = videoPlay->player_->SetSource(source);
    if (ret != 0) {
        static_print_error("set source failed\n");
        (void)DeinitPlayerResources(videoPlay);
        return MEDIA_ERR;
    }
    ret = videoPlay->player_->Prepare();
    if (ret != 0) {
        static_print_error("prepare failed\n");
        return ReleasePlayer(videoPlay);
    }
    ret = SetAudioSessionIdAndStreamType(videoPlay);
    if (ret != 0) {
        return ReleasePlayer(videoPlay);
    }

    ret = videoPlay->player_->SetVideoSurface(videoPlay->surface_);
    if (ret != 0) {
        static_print_error("set video surface failed\n");
        return ReleasePlayer(videoPlay);
    }
    ret = VideoPlay(videoPlay);
    if (ret != 0) {
        return ReleasePlayer(videoPlay);
    }
    VideoStopAndExit(videoPlay);
    SendBackgroundFrame(videoPlay);
    return 0;
}

static bool RequsetAudioFocus(TjdUiVideoCommon *videoPlay)
{
    if (videoPlay->isPureVideo_) {
        return true;
    }
    bool success = g_amInstance.Initialize();
    if (!success) {
        static_print_error("AlbumVideoPlayer::%s: audiomanager init failed", __func__);
        return false;
    }

    AudioSession sessionId = g_amInstance.MakeSessionId();
    if (sessionId == AUDIO_SESSION_ID_NONE) {
        static_print_error("AlbumVideoPlayer::%s: audio session id invalid", __func__);
        return false;
    }

    std::shared_ptr<TjdUiAppOnlineWfVideoPage::VideoPlayerInterruptListener> interruptListener =
        std::make_shared<TjdUiAppOnlineWfVideoPage::VideoPlayerInterruptListener>(videoPlay);
    if (interruptListener == nullptr || interruptListener.get() == nullptr) {
        static_print_error("AlbumVideoPlayer::%s: video player interrupt listener is nullptr", __func__);
        return false;
    }

    AudioInterrupt interrupt = {AUDIO_STREAM_FITNESS_VIDEO, sessionId, interruptListener};
    if (g_amInstance.ActivateAudioInterrupt(interrupt) == INTERRUPT_FAILED) {
        static_print_error("AlbumVideoPlayer::%s: activate audio interrupt failed", __func__);
        return false;
    }

    videoPlay->sessionId_ = sessionId;
    videoPlay->interrupt_ = interrupt;

    return true;
}

static bool ReleaseAudioFocus(TjdUiVideoCommon *videoPlay)
{
    if (videoPlay->isPureVideo_) {
        return true;
    }
    if (g_amInstance.DeactivateAudioInterrupt(videoPlay->interrupt_) != 0) {
        static_print_error("AlbumVideoPlayer::%s: deactivate audio interrupt failed", __func__);
        return false;
    }

    return true;
}



int32_t TjdUiVideoCommon::StartVideoPlay(void)
{
    if (isEntered_) {
        static_print_info("video play is not stop, can not start!");
        return MEDIA_OK;
    }
    isExited_ = false;
    isEntered_ = true;
    MediaThreadattr attr = {"VideoPlayThread", 0x2000, THREAD_SCHED_INVALID, 0, true};
    if (isSyncExitMode_) {
        attr.detached = false;
    }

    threadHandle_ = MediaThreadCreate(VideoPlayThread, this, &attr);
    if (threadHandle_ == NULL) {
        static_print_error("create thread failed\n");
        return MEDIA_ERR;
    }
    //play = this;
    return MEDIA_OK;
}

int32_t TjdUiVideoCommon::PauseVideoPlay(void)
{
    MediaMutexLock(mutex_);
    if (player_ == NULL) {
        static_print_error("can not pause play");
        MediaMutexUnLock(mutex_);
        return MEDIA_ERR;
    }
    if (isPlaybackStopped_ || isPlaybackCompleted_  || interruptHintStop_) {
        static_print_error("current state is stop, can not pause play");
        MediaMutexUnLock(mutex_);
        return MEDIA_ERR;
    }
    int32_t ret = player_->Pause();
    if (ret != MEDIA_OK) {
        static_print_error("pause failed");
        MediaMutexUnLock(mutex_);
        return MEDIA_ERR;
    }
    isPause_ = true;
    MediaMutexUnLock(mutex_);
    return ret;
}


int32_t TjdUiVideoCommon::ResumeVideoPlay(void)
{
    MediaMutexLock(mutex_);
    if (player_ == NULL) {
        static_print_error("can not resume play");
        MediaMutexUnLock(mutex_);
        return MEDIA_ERR;
    }
    if (isPlaybackStopped_ || isPlaybackCompleted_  || interruptHintStop_) {
        static_print_error("current state is stop, can not resume play");
        MediaMutexUnLock(mutex_);
        return MEDIA_ERR;
    }
    int32_t ret = player_->Play();
    if (ret != MEDIA_OK) {
        static_print_error("resume failed");
        MediaMutexUnLock(mutex_);
        return ret;
    }
    isPause_ = false;
    MediaMutexUnLock(mutex_);
    return ret;
}

int32_t TjdUiVideoCommon::StopVideoPlay(void)
{

    MediaMutexLock(mutex_);
    
    if (isPlaybackStopped_ || isPlaybackCompleted_  || interruptHintStop_) {
        if (isLoop_) {
            if (!isPlaybackCompleted_) {
                static_print_info("video play already stopped");
                MediaMutexUnLock(mutex_);
                return MEDIA_OK;
            }
        } else {
            static_print_info("video play already stopped");
            MediaMutexUnLock(mutex_);
            return MEDIA_OK;
        }
    }
    isPlaybackStopped_ = true;
    MediaThreadCondSignal(cond_);
    MediaMutexUnLock(mutex_);
    if (isSyncExitMode_) {
        MediaThreadJoin(&threadHandle_);
        isPlaybackStopped_ = false;
        dynamic_cast<LiteSurface *>(surface_)
            ->ClearBuffers(); // clear buffers safely in sync mode to reduce peak memory
    }
    //play = nullptr;
    return MEDIA_OK;
}

void TjdUiVideoCommon::DestroyVideoPlaySource(void)
{
    needSendBackgroundFrame_ = false;
    StopVideoPlay();
    uint32_t count = 0;
    while (!IsExitCompletely()) {
        count++;
        if (count == WAIT_VIDEO_EXIT_MAX_RETRY_COUNT) {
            static_print_error("media video play exit timeout\n");
            break;
        }
        usleep(WAIT_VIDEO_EXIT_SUCCESS_MS);
    }
}



void *TjdUiVideoCommon::VideoPlayThread(void *arg)
{
    TjdUiVideoCommon *videoPlay = (TjdUiVideoCommon *)arg;
    if (videoPlay->isPlayed_) {
        static_print_error("the video is playing.\n");
        return nullptr;
    }

    bool success = RequsetAudioFocus(videoPlay);
    if (!success) {
        static_print_error("AlbumVideoPlayer::%s: requset audio focus failed", __func__);
        return nullptr;
    }

    int32_t ret = RunVideoPlay(videoPlay);
    if (ret != 0) {
        static_print_error("run video play failed\n");
        (void)ReleaseAudioFocus(videoPlay);
        return nullptr;
    }
    
    success = ReleaseAudioFocus(videoPlay);
    if (!success) {
        static_print_error("AlbumVideoPlayer::%s: release audio focus failed", __func__);
        return nullptr;
    }
    static_print_error("exit all!\n");
    return nullptr;
}

int32_t TjdUiVideoCommon::GetDumpInfo(PlayerDebugInfo *playerInfo)
{
    MediaMutexLock(mutex_);
    if (player_ == NULL) {
        static_print_error("can not get dump info!");
        MediaMutexUnLock(mutex_);
        return MEDIA_ERR;
    }
    int32_t ret = player_->DumpInfo(playerInfo);
    if (ret != MEDIA_OK) {
        static_print_error("get dump info failed");
        MediaMutexUnLock(mutex_);
        return ret;
    }
    MediaMutexUnLock(mutex_);
    return ret;
}

void TjdUiVideoCommon::SetVideoPlayLoop(bool isLoop)
{
    MediaMutexLock(mutex_);
    isLoop_ = isLoop;
    MediaMutexUnLock(mutex_);
}

void TjdUiVideoCommon::SetSyncExitMode(bool isSyncExitMode)
{
    MediaMutexLock(mutex_);
    if (!isEntered_) {
        isSyncExitMode_ = isSyncExitMode;
    }
    MediaMutexUnLock(mutex_);
}

bool TjdUiVideoCommon::IsExitCompletely(void) { return isExited_; }
}