/*
 * Copyright (c) 2026 Amlogic, Inc. All rights reserved.
 *
 * This source code is subject to the terms and conditions defined in the
 * file 'LICENSE' which is part of this source code package.
 *
 * Description: Amlogic MP SDK Player Client Header
 */
#ifdef CONFIG_AMP_SERVER
#pragma once

#include <stddef.h>
#include <stdint.h>
#include <string>
#include <memory>
#include <mutex>

#include "cas/AmlCasBase.h"
#include "Aml_MP/Aml_MP.h"
#include "utils/AmlMpHandle.h"
#include "AmlMpChunkFifo.h"
#include "AmlMpBuffer.h"
#include "Aml_MP_PlayerBase.h"
#include "Aml_MP_PlayerImpl.h"

#include <fmq/AidlMessageQueue.h>
#include <aidl/com/amlogic/aml_mp/player/IAmlMpPlayer.h>
#include <aidl/com/amlogic/aml_mp/player/BnAmlMpPlayerCallback.h>
#include <aidl/com/amlogic/aml_mp/common/AmlMpPlayerEvent.h>
#include <aidl/com/amlogic/aml_mp/common/AmlMpBufPoolDataPacket.h>

#include <binder/IInterface.h>
#include <utils/RefBase.h>
#include <amlogic/am_gralloc_ext.h>
#include <system/window.h>
#include <video_tunnel.h>
#include <hardware/gralloc1.h>

using namespace aml_mp;
using ::android::AidlMessageQueue;
using ::aidl::android::hardware::common::fmq::MQDescriptor;
using ::aidl::android::hardware::common::fmq::SynchronizedReadWrite;
using ::aidl::com::amlogic::aml_mp::common::AmlMpBufPoolDataPacket;
using aidl::com::amlogic::aml_mp::common::AmlMpPlayerEvent;
using aidl::com::amlogic::aml_mp::player::BnAmlMpPlayerCallback;
using DataQueueMQ =     AidlMessageQueue<AmlMpBufPoolDataPacket, SynchronizedReadWrite>;
using FreeQueueMQ =     AidlMessageQueue<int32_t, SynchronizedReadWrite>;

/**
 * Aml_MP_PlayerClient
 *
 * SDK-side player instance.
 *
 * Responsibilities:
 *  - Owns playback state and controls
 *  - Builds AmlMpPlayerParam and talks to IAmlMpPlayer (Binder)
 *  - All playback and parameter logic lives here
 *
 * NOTE:
 *  - This class is NOT part of the frozen AIDL ABI, but must
 *    respect the frozen Binder interfaces.
 *  - Legacy void* based APIs are kept for compatibility only.
 */
class Aml_MP_PlayerClient final : public Aml_MP_PlayerBase {
public:
    using status = ::ndk::ScopedAStatus;
    explicit Aml_MP_PlayerClient(const Aml_MP_PlayerCreateParams* createParams);
    ~Aml_MP_PlayerClient();

    int getId() const { return player_id; }
/*
    int getPlayerId() const { return player_id; }
    int getChannelId() const { return create_params.channelId; }
    int getDemuxId() const { return create_params.demuxId; }
    int getSourceType() const { return create_params.sourceType; }
    uint64_t getOptions() const { return create_params.options; }
*/

    int registerEventCallback(Aml_MP_PlayerEventCallback cb, void* userData) override;

    int setVideoParams(const Aml_MP_VideoParams* params) override;
    int setAudioParams(const Aml_MP_AudioParams* params) override;
    int setSubtitleParams(const Aml_MP_SubtitleParams* params) override;
    int setCasSession(AML_MP_CASSESSION casSession) override;
    int setIptvCASParams(Aml_MP_CASServiceType serviceType, const Aml_MP_IptvCASParams* params) override;

    int start() override;
    int stop() override;
    int pause() override;
    int resume() override;
    int flush() override;

    int setPlaybackRate(float rate) override;
    int setPlaybackRate2(float rate, Aml_MP_VideoDecodeMode decodeMode) override;
    int getPlaybackRate(float* rate) override;

    int switchAudioTrack(const Aml_MP_AudioParams* params) override;
    int switchSubtitleTrack(const Aml_MP_SubtitleParams* params) override;

    int writeData(const uint8_t* buffer, size_t size) override;
    int writeEsData(Aml_MP_StreamType streamType, const uint8_t* buffer, size_t size, int64_t pts) override;


    int getCurrentPts(Aml_MP_StreamType streamType, int64_t* pts) override;
    int getFirstPts(Aml_MP_StreamType streamType, int64_t* pts) override;
    int getBufferStat(Aml_MP_BufferStat* bufferStat) override;
    int setANativeWindow(ANativeWindow* nativeWindow) override;
    int setVideoWindow(int32_t x, int32_t y, int32_t width, int32_t height) override;

    int setVolume(float volume) override;
    int getVolume(float* volume) override;

    int showVideo() override;
    int hideVideo() override;
    int showSubtitle() override;
    int hideSubtitle() override;
    int setParameter(Aml_MP_PlayerParameterKey key, void* parameter) override;
    int getParameter(Aml_MP_PlayerParameterKey key, void* parameter) override;
    int setSubtitleWindow(int x, int y, int width, int height) override;

    int setAVSyncSource(Aml_MP_AVSyncSource syncSource) override;
    int setPcrPid(int pid) override;
    int startVideoDecoding() override;
    int stopVideoDecoding() override;
    int startAudioDecoding() override;
    int stopAudioDecoding() override;
    int startSubtitleDecoding() override;
    int stopSubtitleDecoding() override;
    int startADDecoding() override;
    int stopADDecoding() override;

    int setADParams(Aml_MP_AudioParams* params) override;
    int setADVolume(float volume) override;
    int getADVolume(float* volume) override;

    int getDecodingState(Aml_MP_StreamType streamType, AML_MP_DecodingState* decodingState) override;

private:
    bool connectToService();

    Aml_MP_PlayerCreateParams mCreateParams;
    int player_id = -1;

    mutable std::mutex mutex;
    std::shared_ptr<aidl::com::amlogic::aml_mp::player::IAmlMpPlayer> mPlayerService;
    std::atomic<bool> mServiceConnected = false;

    char mName[64] = {};

    BufPoolNode *mBufPoolBufs = nullptr;
    int32_t mBufPoolBufCnt = -1;
    int32_t mBufPoolBufOne = -1;
    std::atomic<bool> mBufPoolHasInit = false;
    int32_t mBufPoolFd = -1;
    void *mBufPoolPtr = nullptr;
    std::unique_ptr<DataQueueMQ> mBufPoolDataMq = nullptr;
    std::unique_ptr<FreeQueueMQ> mBufPoolFreeMq = nullptr;
    void InitBufPool();
    void FreeBufPool();
    int32_t setBufPool2Servier();

    ANativeWindow* mNativeWindow = nullptr;
    android::sp<android::NativeHandle> mSidebandHandle = nullptr;
    int mTunnelId = -1;
    int mMesonVtFd = -1;

    void clearTunnelId();
    int32_t allocTunnelId();

    class ClientEventCallBack : public BnAmlMpPlayerCallback {
    public:
        ClientEventCallBack(aml_mp::wptr<Aml_MP_PlayerClient>& weakThis, int32_t playerId,
            Aml_MP_PlayerEventCallback cb = nullptr, void* userData = nullptr);
        ~ClientEventCallBack() {}
        status onPlayerEvent(const AmlMpPlayerEvent &event);
        int setCallBack(Aml_MP_PlayerEventCallback cb, void *userData);

    private:
        Aml_MP_PlayerEventCallback mCb = nullptr;
        void* mUserData = nullptr;
        wptr<Aml_MP_PlayerClient> mClient;
        mutable std::mutex mutex;
        char mName[64] = {};
    };

    std::shared_ptr<ClientEventCallBack> mCallback = nullptr;


    Aml_MP_CASServiceType mCasServiceType{AML_MP_CAS_SERVICE_TYPE_INVALID};
    Aml_MP_IptvCASParams mIptvCasParams;

    sptr<AmlMpBuffer> mWriteBuffer;
    AmlMpChunkFifo mTsBuffer;
    size_t mCacheEcmSize = 0;
    WaitingEcmMode mWaitingEcmMode = kWaitingEcmSynchronous;
    bool mWaitingEcmAtServer = true;

    bool mFirstEcmWritten = false;
    bool mIsStandaloneCas = false;
    bool mHasStartCas = false;
    sptr<AmlCasBase> mCasHandle = nullptr;
    std::vector<int32_t> mEcmPids;
    void startDescrambling_l();
    void stopDescrambling_l();
    int processEcmBeforeWrite(const uint8_t* buffer, size_t size);
    void resetEcmVariables();
    void setEcmPidToServer();
    int doWriteTsData(const uint8_t* buffer, size_t size);
    int makeCallbackToServer(Aml_MP_PlayerEventCallback cb = nullptr, void* userData = nullptr);

    static void onBinderDied(void* cookie);
    std::atomic<bool> mServiceDead = false;
    AIBinder_DeathRecipient* mRecipient = nullptr;
    AIBinder* mRawBinder = nullptr;
};

#endif