/*----------------------------------------------------------------------------
 * Copyright (c) TJD Technologies Co., Ltd. 2025. All rights reserved.
 *
 * Description: TjdUiAppPlayerModel.cpp
 *
 * Author: luziquan@ss-tjd.com
 *
 * Create: 2024-06-07
 *--------------------------------------------------------------------------*/

#include "TjdUiAppPlayerModel.h"
#include "TjdUiAppPlayerPresenter.h"
#include "TjdUiSettingCenter.h"
#include "UiConfig.h"
#include "audio_base_type.h"
#include "audio_manager.h"
#include "audio_stream_in.h"
#include "audio_stream_out.h"
#include "bts_a2dp_sink.h"
#include "bts_a2dp_source.h"
#include "bts_br_gap.h"
#include "bts_feature.h"
#include "dirent.h"
#include "media_thread_adapt.h"
#include "ohos_types.h"
#include "player.h"
#include "service_charger.h"
#include "stdint.h"
#include "sys_config.h"
#include "thread_adapter.h"
#include <string>

extern "C"
{
#include "ble_api.h"
#include "service_bt.h"
}

#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

namespace TJD {

static MutexId g_mutex;

extern BtAvrcpTgInf *GetAvrcpTgInf(void);

TjdUiAppPlayerModel::TjdUiAppPlayerModel() { g_mutex = MUTEX_InitValue(); }

TjdUiAppPlayerModel::~TjdUiAppPlayerModel() {}

TjdUiAppPlayerModel *TjdUiAppPlayerModel::GetInstance(void)
{
    static TjdUiAppPlayerModel instance;
    return &instance;
}

void TjdUiAppPlayerModel::InitBluetoothPlayer(void)
{
    InitBtA2dpSourceEvent();
    InitBtA2dpSinkEvent();
    InitBtHeadsetEvent();
}

int TjdUiAppPlayerModel::PlayerInit(void)
{
    sliceId = PlayersListGroup::GetInstance()->GetCase(currentIndex_);
    if (sliceId == nullptr) {
        static_print_error("GetCase %d sliceId err !!!", currentIndex_);
        char strFile[15] = "No music files";
        sliceId = strFile;
    }
    std::string strSongName = sliceId;
    std::string pureName = strSongName.substr(0, strSongName.rfind("."));
    static_print_info("PlayerInit, url: %s ", sliceId);
    std::string strSrcMusic(TJD_FS_DIR_MUSIC);
    uri_ = strSrcMusic + "/" + sliceId;
    return 0;
}

void TjdUiAppPlayerModel::AudioInit(void)
{
    if (audioInitStatus_) {
        static_print_info("audioInitStatus_ is true");
        return;
    }
    Audio::AudioManager &amIntance = Audio::AudioManager::GetInstance();
    audioInitStatus_ = amIntance.Initialize();
    playerCtr_ = std::make_shared<OHOS::Media::Player>();
    playerCallback_ = std::make_shared<PlayerCallbackImpl>();
    static_print_info("AudioInit end!");
}

bool TjdUiAppPlayerModel::GetAudioInitStatus(void) { return audioInitStatus_; }

int TjdUiAppPlayerModel::PlayerStart()
{
    int32_t ret = 0;

    // 设置回调函数
    playerCtr_->SetPlayerCallback(playerCallback_);
    // 申请资源
    source_ = std::make_shared<OHOS::Media::Source>(uri_, header_);
    playerCtr_->SetSource(*source_);
    playerCtr_->Prepare();
    if (!isActivateAudioInterrupt_) {
        // 申请焦点
        Audio::AudioManager &amIntance = Audio::AudioManager::GetInstance();
        sessionId_ = amIntance.MakeSessionId();
        if (sessionId_ == AUDIO_SESSION_ID_NONE) {
            static_print_error("session invalid");
            return OHOS_FAILURE;
        }
        playerInterruptListener_ = std::make_shared<PlayerInterruptListener>();
        playerInterruptListener_->SetOwner(playerCtr_);
        interrupt_ = {AUDIO_STREAM_MUSIC, sessionId_, playerInterruptListener_};
        // 激活音频中断 5s超时
        if (amIntance.ActivateAudioInterrupt(interrupt_) == INTERRUPT_FAILED) {
            static_print_error("ActivateAudioInterrupt faild");
            return OHOS_FAILURE;
        }
        isActivateAudioInterrupt_ = true;
    }
    playerCtr_->SetAudioSessionId(sessionId_);
    // 播放
    ret = playerCtr_->Play();
    if (ret != 0) {
        playerCtr_->Stop();  // 暂停
        playerCtr_->Reset(); // 初始化
        TjdUiAppPlayerPresenter *playersPresenter = TjdUiAppPlayerPresenter::GetInstance();
        if (playersPresenter != nullptr) {
            playersPresenter->PlayerBackReset();
        } else {
            SetPlayButtonState(false);
        }
        Audio::AudioManager::GetInstance().DeactivateAudioInterrupt(interrupt_);
        isActivateAudioInterrupt_ = false;
    }
    return OHOS_SUCCESS;
}

int TjdUiAppPlayerModel::PlayerStop(void)
{
    int state;
    state = GetPlayerState();
    if (state == -1) {
        static_print_error("Get state of player failed!!");
        return EXECUTE_FUNC_FAILED;
    }
    if (playerCtr_.get() == nullptr) {
        static_print_error("playerCtr_.get() is nullptr!!");
        return EXECUTE_FUNC_FAILED;
    }
    if (state == OHOS::Media::PlayerStates::PLAYER_STARTED ||
        state == OHOS::Media::PlayerStates::PLAYER_PLAYBACK_COMPLETE) {
        int ret = playerCtr_->Stop();
        if (ret != 0) {
            static_print_error("Stop err, ret:%d", ret);
            return EXECUTE_FUNC_FAILED;
        }
        ret = playerCtr_->Reset();
        if (ret != 0) {
            static_print_error("Reset err, ret:%d", ret);
            return EXECUTE_FUNC_FAILED;
        } else {
            SetPlayButtonState(false);
            ConncetBtResetButton();
        }
        Audio::AudioManager::GetInstance().DeactivateAudioInterrupt(interrupt_);
        return NORMAL;
    } else if (state == OHOS::Media::PlayerStates::PLAYER_PAUSED) {
        int ret = playerCtr_->Reset();
        if (ret != 0) {
            static_print_error("Reset err, ret:%d", ret);
            return EXECUTE_FUNC_FAILED;
        } else {
            SetPlayButtonState(false);
            ConncetBtResetButton();
        }
        Audio::AudioManager::GetInstance().DeactivateAudioInterrupt(interrupt_);
        return NORMAL;
    } else if (state == OHOS::Media::PlayerStates::PLAYER_STOPPED) {
        return SONG_ALREADY_STOP;
    }
    return NORMAL;
}

const bd_addr_t *TjdUiAppPlayerModel::GetLastConnedAddr() { return tjd_get_lastconned_addr(); }

uint8_t TjdUiAppPlayerModel::GetBartteryLevel(void) { return tjd_service_charger_get_battery(); }

static int NotifySnkKey(int key_operation)
{
    bd_addr_t bd_addr = a2dp_snk_get_active_device();
    int ret = avrcp_ct_press_button(&bd_addr, key_operation);
    if (ret != 0) {
        static_print_error("avrcp_ct_press_button err, ret:%d", ret);
    }
    ret = avrcp_ct_release_button(&bd_addr, key_operation);
    if (ret != 0) {
        static_print_error("avrcp_ct_release_button err, ret:%d", ret);
    }
    return ret;
}

void TjdUiAppPlayerModel::SetVolume(int32_t volume)
{
    if (playerDeviceState_ == PlayerSource::PLAYER_SOURCE_PHONE && IsConnectPhone()) {
        bd_addr_t bd_addr = a2dp_snk_get_active_device();
        // TODO: 当前版本不准备同步手机端音量
        uint8_t sounding = volume * 127 / 100; // 100：本地音量最大值
        avrcp_ct_set_absolute_volume(&(GetAvrcpTgInf()->bd_addr), sounding);
        Audio::AudioManager::GetInstance().SetVolume(AUDIO_STREAM_A2DP_MUSIC, volume); // 本地音量设置
        return;
    }
    Audio::AudioManager::GetInstance().SetVolume(AUDIO_STREAM_MUSIC, volume); // 本地音量设置
}

int32_t TjdUiAppPlayerModel::GetA2dpVolume(void)
{
    return Audio::AudioManager::GetInstance().GetVolume(AUDIO_STREAM_A2DP_MUSIC);
}

int32_t TjdUiAppPlayerModel::GetLocalVolume(void)
{
    return Audio::AudioManager::GetInstance().GetVolume(AUDIO_STREAM_MUSIC);
}

bool TjdUiAppPlayerModel::StartHeadsetPlug(void)
{
    uint8_t ret = tjd_service_bt_scan_start();
    if (ret != 0) {
        static_print_error("tjd_service_bt_scan_start_open fail, ret:%d.", ret);
        return false;
    }
    return true;
}

bool TjdUiAppPlayerModel::StopHeadsetPlug(void)
{
    uint8_t ret = tjd_service_bt_scan_stop();
    if (ret != 0) {
        static_print_error("tjd_service_bt_scan_stop_open fail, ret:%d.", ret);
        return false;
    }
    return true;
}

osal_list_head *TjdUiAppPlayerModel::GetHeadsetInfo() { return tjd_get_found_dev_list(); }

void TjdUiAppPlayerModel::SetPhoneAudioEnable(bool enable)
{
    int ret = 0;
    if (enable) {
        ret = a2dp_snk_connect(GetLastConnedAddr());
        static_print_info("a2dp_snk_connect %d", ret);
    } else {
        ret = a2dp_snk_disconnect(GetLastConnedAddr());
        static_print_info("a2dp_snk_disconnect %d", ret);
    }
}

int TjdUiAppPlayerModel::ConnectHeadset(const bd_addr_t &addr)
{
    /* 恢厂后耳机连接要开启BT广播否则会导致AVRCP无法音量控制 */
    bool ret = gap_br_set_bt_scan_mode(GAP_SCAN_MODE_CONNECTABLE, 60);
    if (!ret) {
        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "ConnectRemoteDevice gap_br_set_bt_scan_mode ret = 0x%x", ret);
    }
    errcode_t retVal = gap_connect_remote_device(&addr);
    WEARABLE_LOGI(WEARABLE_LOG_MODULE_APP, "ConnectRemoteDevice gap_connect_remote_device ret = 0x%x", retVal);
    return retVal;
}

bool TjdUiAppPlayerModel::IsConnectHeadset(const bd_addr_t &addr)
{
    tjd_service_bt_is_connect(&addr);
    osDelay(50);
    return tjd_check_bt_is_acl_connected();
}

bool TjdUiAppPlayerModel::UnpairHeadset(const bd_addr_t &addr)
{
    errcode_t ret = a2dp_src_disconnect(&addr);
    if (ret != ERRCODE_SUCC) {
        static_print_debug("a2dp_src_disconnect fail, ret:%x.", ret);
        return false;
    }

    return gap_remove_pair(&addr);
}

bool TjdUiAppPlayerModel::DisconnectHeadset(const bd_addr_t &addr)
{
    errcode_t ret = a2dp_src_disconnect(&addr);
    if (ret != ERRCODE_SUCC) {
        static_print_debug("a2dp_src_disconnect fail, ret:%x.", ret);
        return false;
    }
    return true;
}

bool TjdUiAppPlayerModel::IsConnectBt(void) { return tjd_get_bt_is_connect(); }

bool TjdUiAppPlayerModel::IsConnectHeadset(void)
{
    bd_addr_t activeBdAddr = a2dp_src_get_active_device();
    int32_t connState = a2dp_src_get_device_connect_state(&activeBdAddr);
    if (connState == PROFILE_STATE_CONNECTED) {
        return true;
    }
    return false;
}

bool TjdUiAppPlayerModel::IsConnectPhone(void)
{
    bd_addr_t activeBdAddr = a2dp_snk_get_active_device();
    int state = a2dp_snk_get_device_connect_state(&activeBdAddr);
    if (state == PROFILE_STATE_CONNECTED) {
        return true;
    }
    return false;
}

void TjdUiAppPlayerModel::AvrcpCtStatusNotification(avrcp_play_status_t status)
{
    avrcpPlayStatus_ = status;
    if (avrcpPlayStatus_ == avrcp_play_status_t::AVRCP_PLAY_STATUS_PLAYING) {
        playerDeviceState_ = PlayerSource::PLAYER_SOURCE_PHONE;
    }
    TjdUiAppPlayerPresenter *presenter = TjdUiAppPlayerPresenter::GetInstance();
    if (presenter == nullptr) {
        /* 如果没有打开播放页面，并且手机播放停止，则切换回默认设备 */
        if (avrcpPlayStatus_ == avrcp_play_status_t::AVRCP_PLAY_STATUS_PAUSED ||
            avrcpPlayStatus_ == avrcp_play_status_t::AVRCP_PLAY_STATUS_STOPPED) {
            playerDeviceState_ = PlayerSource::PLAYER_SOURCE_WATCH;
        }
        static_print_error("player presenter is nullptr");
        return;
    }
    if (playerDeviceState_ == PlayerSource::PLAYER_SOURCE_PHONE) {
        presenter->PhonePlayerStatusChange(status);
    }
}

bool TjdUiAppPlayerModel::PhoneAudioIsPlaying(void)
{
    bd_addr_t activeBdAddr = a2dp_snk_get_active_device();
    int state = a2dp_snk_get_playing_state(&activeBdAddr);
    if (state == A2DP_IS_PLAYING) {
        return true;
    }
    return false;
}

void TjdUiAppPlayerModel::NextSong(int16_t index)
{
    SetCurrentIndex(index);
    // 播放
    sliceId = PlayersListGroup::GetInstance()->GetCase(index);
    if (sliceId == nullptr) {
        static_print_error("GetCase %d sliceId err!!!", index);
        return;
    }
    std::string strSrcMusic(TJD_FS_DIR_MUSIC);
    SetPlayerUri(strSrcMusic + "/" + sliceId);
    std::string strSongName = sliceId;
    std::string pureName = strSongName.substr(0, strSongName.rfind("."));
    TjdUiAppPlayerPresenter *playersPresenter = TjdUiAppPlayerPresenter::GetInstance();
    if (playersPresenter != nullptr) {
        playersPresenter->SetMusicName(pureName.c_str());
    }
    int32_t ret;
    int32_t playerState;
    playerCtr_->GetPlayerState(playerState);
    if ((playerState == OHOS::Media::PlayerStates::PLAYER_STARTED) ||
        (playerState == OHOS::Media::PlayerStates::PLAYER_PLAYBACK_COMPLETE)) {
        /* start play */
        ret = playerCtr_->Stop(); // 停止
        ret = playerCtr_->Reset();
        ret = PlayerStart(); // 播放
        if (ret != 0) {
            /* stop and exit */
            ret = playerCtr_->Stop(); // 停止
            ret = playerCtr_->Reset();
        }
    } else if (playerState == OHOS::Media::PlayerStates::PLAYER_PAUSED ||
               (playerState == OHOS::Media::PlayerStates::PLAYER_IDLE)) {
        ret = playerCtr_->Reset();
    }
}

void TjdUiAppPlayerModel::LoopingPlayout()
{
    int16_t index;
    std::list<PlayerCaseInfo> &playersCaseList = PlayersListGroup::GetInstance()->GetCase();
    index = GetCurrentIndex();
    if ((index > static_cast<int16_t>(playersCaseList.size() - 1)) || (index < 0)) {
        static_print_error("currentIndex err");
        SetCurrentIndex(0);
        return;
    }

    // 下一曲
    if (++index > static_cast<int16_t>(playersCaseList.size() - 1)) {
        index = 0;
    }
    NextSong(index);
}

void TjdUiAppPlayerModel::SequencePlayout()
{
    int16_t index;
    std::list<PlayerCaseInfo> &playersCaseList = PlayersListGroup::GetInstance()->GetCase();
    index = GetCurrentIndex();
    if ((index > static_cast<int16_t>(playersCaseList.size() - 1)) || (index < 0)) {
        static_print_error("currentIndex err");
        SetCurrentIndex(0);
        return;
    }

    // 下一曲
    if (++index > static_cast<int16_t>(playersCaseList.size() - 1)) {
        playerCtr_->Stop();  // 暂停
        playerCtr_->Reset(); // 初始化
        TjdUiAppPlayerPresenter *playersPresenter = TjdUiAppPlayerPresenter::GetInstance();
        if (playersPresenter != nullptr) {
            playersPresenter->PlayerBackReset();
        } else {
            SetPlayButtonState(false);
        }
        index = playersCaseList.size() - 1;
    }
    NextSong(index);
}

void TjdUiAppPlayerModel::PreviousPlayout()
{
    int16_t index;
    std::list<PlayerCaseInfo> &playersCaseList = PlayersListGroup::GetInstance()->GetCase();
    index = GetCurrentIndex();
    if ((index > static_cast<int16_t>(playersCaseList.size() - 1)) || (index < 0)) {
        static_print_error("currentIndex err");
        SetCurrentIndex(0);
        return;
    }

    // 上一曲
    if (--index < 0) {
        index = playersCaseList.size() - 1;
    }
    NextSong(index);
}

void TjdUiAppPlayerModel::PhoneAudioPlay()
{
    Audio::AudioManager::GetInstance().SetVolume(AUDIO_STREAM_A2DP_MUSIC, 255 * 0.2); // 本地音量设置
    int ret = NotifySnkKey(AVRCP_KEY_PLAY);
    if (ret != 0) {
        static_print_error("[TjdUiAppPlayerModel::PhoneAudioPlay] avrcp_ct_release_button err, ret:%d", ret);
    }
}

void TjdUiAppPlayerModel::PhoneAudioStop()
{
    Audio::AudioManager::GetInstance().SetVolume(AUDIO_STREAM_A2DP_MUSIC, 0);
    int ret = NotifySnkKey(AVRCP_KEY_PAUSE);
    if (ret != 0) {
        static_print_error("[TjdUiAppPlayerModel::PhoneAudioStop] avrcp_ct_release_button err, ret:%d", ret);
    }
}

void TjdUiAppPlayerModel::PhoneAudioPrevious()
{
    bd_addr_t bd_addr = a2dp_snk_get_active_device();
    int ret = NotifySnkKey(AVRCP_KEY_BACKWARD);
    if (ret != 0) {
        static_print_error("[TjdUiAppPlayerModel::PhoneAudioPrevious] avrcp_ct_release_button err, ret:%d", ret);
    }
}

void TjdUiAppPlayerModel::PhoneAudioForward()
{
    bd_addr_t bd_addr = a2dp_snk_get_active_device();
    int ret = NotifySnkKey(AVRCP_KEY_FORWARD);
    if (ret != 0) {
        static_print_error("[TjdUiAppPlayerModel::PhoneAudioForward] avrcp_ct_press_button err, ret:%d", ret);
    }
}

void TjdUiAppPlayerModel::RandomPlayout()
{
    int16_t random;
    int16_t indexMax;
    srand((unsigned)time(nullptr));
    std::list<PlayerCaseInfo> &playersCaseList = PlayersListGroup::GetInstance()->GetCase();
    indexMax = playersCaseList.size() - 1;
    random = (rand() % (indexMax + 1));
    if ((random > static_cast<int16_t>(playersCaseList.size() - 1)) || (random < 0)) {
        SetCurrentIndex(0);
        return;
    }
    if (GetCurrentIndex() == random) {
        random++;
        if (random > static_cast<int16_t>(playersCaseList.size() - 1)) {
            random = 0;
        }
    }
    NextSong(random);
}

void TjdUiAppPlayerModel::PlaySwitching(void)
{
    int32_t ret;
    static_print_info("PlayerModel:%d", static_cast<int>(playerModel_));
    switch (playerModel_) {
    case PlayMode::SEQUENCE:
        // 顺序
        SequencePlayout();
        break;
    case PlayMode::REPEATS:
        // 重复
        ret = playerCtr_->Stop(); // 停止
        ret = playerCtr_->Reset();
        PlayerStart(); // 播放
        break;
    case PlayMode::RANDOM:
        // 随机
        RandomPlayout();
        break;
    }
}

int32_t TjdUiAppPlayerModel::GetPlayerStatus()
{
    int32_t playerState;
    if (playerCtr_.get() == nullptr) {
        static_print_error("PlayersModel::GetPlayerStatus playerCtr_ is nullptr");
        return EXECUTE_FUNC_FAILED;
    }
    playerCtr_->GetPlayerState(playerState);

    switch (playerState) {
    case OHOS::Media::PLAYER_STARTED:
        playerState = AVRCP_PLAY_STATUS_PLAYING;
        break;
    case OHOS::Media::PLAYER_PAUSED:
        playerState = AVRCP_PLAY_STATUS_PAUSED;
        break;
    case OHOS::Media::PLAYER_STOPPED:
        playerState = AVRCP_PLAY_STATUS_STOPPED;
        break;
    default:
        playerState = AVRCP_PLAY_STATUS_STOPPED;
        break;
    }
    return playerState;
}

void TjdUiAppPlayerModel::SetBTMusicPlay(avrcp_key_operation_t notification)
{
    int ret = 0;
    bd_addr_t bd_addr = a2dp_src_get_active_device();
    // 设置耳机的状态暂停
    if (notification == AVRCP_KEY_PLAY) {
        ret = a2dp_src_start_playing(&bd_addr);
        avrcp_tg_notify_playback_status_changed(AVRCP_PLAY_STATUS_PLAYING);
        static_print_debug("[TjdUiAppPlayerModel::SetBTMusicPlay] a2dp_src_start_playing err, ret:%d", ret);
    } else if (notification == AVRCP_KEY_PAUSE) {
        ret = a2dp_src_suspend_playing(&bd_addr);
        avrcp_tg_notify_playback_status_changed(AVRCP_PLAY_STATUS_PAUSED);
        static_print_debug("[TjdUiAppPlayerModel::SetBTMusicPlay] a2dp_src_suspend_playing err, ret:%d", ret);
    }
}

// 蓝牙连接和本地音乐的播放
bool TjdUiAppPlayerModel::ConnectBtAndLocalPlay(int32_t connCtState, int32_t connTgState)
{
    int ret = 0;
    if (playerCtr_.get() == nullptr) {
        static_print_error("[TjdUiAppPlayerModel::ConnectBtAndLocalPlay] GetPlayerCtr is nullptr ");
        return false;
    }
    int32_t playerState = 0;
    playerCtr_->GetPlayerState(playerState);

    // 当前是暂停状态则直接播放
    if (playerState == OHOS::Media::PlayerStates::PLAYER_PAUSED) {
        GetPlayerCtr()->Play();
    } else {
        ret = PlayerStart(); // 本地播放
        if (ret != 0) {
            static_print_error("PlayerStart err, ret:%d", ret);
        }
    }
    if (IsConnectHeadset()) {
        SetBTMusicPlay(avrcp_key_operation_t::AVRCP_KEY_PLAY);
    }
    return false;
}

// 蓝牙连接和本地音乐的暂停
void TjdUiAppPlayerModel::ConnectBtAndLocalPause(int32_t connCtState, int32_t connTgState)
{
    int ret;
    ret = GetPlayerCtr()->Pause(); // 本地暂停
    if (ret != 0) {
        static_print_error("PlayerPause err, ret:%d", ret);
    }
    if (IsConnectHeadset()) {
        SetBTMusicPlay(avrcp_key_operation_t::AVRCP_KEY_PAUSE);
    }
}

void TjdUiAppPlayerModel::ConncetBtResetButton()
{
    int32_t connCtState = avrcp_ct_get_device_connect_state(tjd_get_lastconned_addr());
    int32_t connTgState = avrcp_tg_get_device_connect_state(tjd_get_lastconned_addr());
    if (connCtState == PROFILE_STATE_CONNECTED || connTgState == PROFILE_STATE_CONNECTED) {
        if (TjdUiAppPlayerPresenter::GetInstance() == nullptr) {
            static_print_error("PlayersPresenter::GetInstance() == nullptr");
            return;
        }
        TjdUiAppPlayerPresenter::GetInstance()->PlayerButtonReset();
    }
}

int TjdUiAppPlayerModel::GetPlayerState(void)
{
    int state;
    if (playerCtr_.get() == nullptr) {
        static_print_error("playerCtr_.get() is nullptr!!");
        return -1;
    }
    playerCtr_->GetPlayerState(state);
    return state;
}

#pragma region 音乐列表文件
PlayersListGroup::~PlayersListGroup()
{
    if (playersCaseList_ != nullptr) {
        playersCaseList_->clear();
    }
    delete playersCaseList_;
    playersCaseList_ = nullptr;
}

PlayersListGroup *PlayersListGroup::GetInstance()
{
    static PlayersListGroup instance;
    return &instance;
}

void PlayersListGroup::AddCase(PlayerCaseInfo testCaseInfo)
{
    if (playersCaseList_ == nullptr) {
        return;
    }
    playersCaseList_->push_back(testCaseInfo);
}

void PlayersListGroup::SetUpListCase(void)
{
    int16_t ret;
    if (playersCaseList_ == nullptr) {
        playersCaseList_ = new std::list<PlayerCaseInfo>();
    }
    playersCaseList_->clear();
    ret = GetAllFiles();
    if (ret == OHOS_FAILURE) {
        return;
    }
    static_print_debug("playersCaseList_ size %d", playersCaseList_->size());
}

void PlayersListGroup::RemoveCase(int16_t index)
{
    if (playersCaseList_ == nullptr) {
        return;
    }
    for (auto it = playersCaseList_->begin(); it != playersCaseList_->end();) {
        if (index == it->index) {
            RemoveTargetFile(it->sliceId);
            it = playersCaseList_->erase(it);
            return;
        } else {
            ++it;
        }
    }
}

char *PlayersListGroup::GetCase(int16_t index)
{
    if (index < 0 || playersCaseList_ == nullptr) {
        return nullptr;
    }
    for (auto it = playersCaseList_->begin(); it != playersCaseList_->end(); ++it) {
        if (index == it->index) {
            return it->sliceId;
        }
    }
    return nullptr;
}

int PlayersListGroup::GetAllFiles()
{
    int ret;
    int i{0};
    struct dirent *direntp;
    struct PlayerCaseInfo playerCaseInfo;
    static_print_debug("PlayersView::GetAllFiles");
    // 打开目录
    DIR *dirp = opendir(TJD_FS_DIR_MUSIC);
    // 遍历文件
    if (dirp != nullptr) {
        while ((direntp = readdir(dirp)) != nullptr) {
            std::string filename(direntp->d_name);
            // 检查文件名的后缀是否为.mp3
            if (filename.rfind(".mp3") == filename.length() - 4) {
                ret = memcpy_s(playerCaseInfo.sliceId, 256, direntp->d_name, 256);
                if (ret != OHOS_SUCCESS) {
                    static_print_error("memcpy_s err %d.", ret);
                    closedir(dirp);
                    return OHOS_FAILURE;
                }
                playerCaseInfo.index = i;
                static_print_debug("song[%d] Name %s.", playerCaseInfo.index, playerCaseInfo.sliceId);
                i++;
                playersCaseList_->push_back(playerCaseInfo);
            }
        }
    } else {
        static_print_debug("PlayersView::opendir err!");
        return OHOS_FAILURE;
    }
    // 关闭目录
    closedir(dirp);
    static_print_debug("PlayersView::GetAllFiles end!");
    return OHOS_SUCCESS;
}

void PlayersListGroup::RemoveTargetFile(const char *sliceId)
{
    std::string filePath = std::string(TJD_FS_DIR_MUSIC) + "/" + sliceId;
    if (remove(filePath.c_str()) == 0) {
        static_print_debug("File %s successfully deleted", filePath.c_str());
    } else {
        static_print_error("Error deleting file %s", filePath.c_str());
    }
}
#pragma endregion
} // namespace TJD