/*
 * Copyright (c) 2023 Fancy Code.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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.
 */
#ifndef MCU_MANAGER_IMPL_H
#define MCU_MANAGER_IMPL_H
#include "IMcuManager.h"
#include "McuDevice.h"
#include "McuProtocol.h"
#include <functional>
#include <list>
#include <map>
#include <mutex>
using std::placeholders::_1;
using McuAskHandleFunc = std::function<void(std::shared_ptr<VMcuRecv> &)>;
enum class OtherSideSendType
{
    SEND_IPC_MISSION,
    SEND_HEART_BEAT,
    GET_INTERVAL_START,
    GET_DATE_TIME,
    END
};
class McuManagerImpl : public McuDevice, public McuProtocol, public std::enable_shared_from_this<McuManagerImpl>
{
public:
    McuManagerImpl();
    virtual ~McuManagerImpl() = default;
    std::shared_ptr<VProtocolBase> SharedFromThis(void) override;
    const StatusCode Init(void) override;
    const StatusCode UnInit(void) override;
    const StatusCode SetMcuMonitor(std::shared_ptr<VMcuMonitor> &monitor) override;
    const StatusCode GetIpcMission(std::shared_ptr<VMcuAsk> &ask) override;
    const StatusCode CutOffPowerSupply(std::shared_ptr<VMcuAsk> &ask) override;
    const StatusCode FeedWatchDog(std::shared_ptr<VMcuAsk> &ask) override;
    const StatusCode SetFeedingCycleForWatchDog(std::shared_ptr<VMcuAsk> &ask, const unsigned char &hour,
                                                const unsigned char &min, const unsigned char &second) override;
    const StatusCode SetDateTime(std::shared_ptr<VMcuAsk> &ask, const McuAskDateTime &value) override;
    const StatusCode SetPirSensitivity(std::shared_ptr<VMcuAsk> &ask, const unsigned char &sensitivity) override;
    const StatusCode ContorlInfraredLight(std::shared_ptr<VMcuAsk> &ask, const ControlLight &control) override;
    const StatusCode GetPhotosensitivityValue(std::shared_ptr<VMcuAsk> &ask) override;
    const char *PrintIpcMissionString(const IpcMission &mission) override;

private:
    std::shared_ptr<VMcuMonitor> GetMcuMonitor(void);

private:
    void OtherSideSendIpcMission(const unsigned int &serialNumber, const unsigned char &mission) override;
    /**
     * @brief The heartbeat packet must be processed by the state machine in the main thread. When the state machine
     * blocks/freezes, it can be restored by the external microcontroller after powering off and restarting.
     * This function has been cancelled.
     * @param serialNumber
     */
    void OtherSideSendHearBeat(const unsigned int &serialNumber) override;
    void OtherSideSendGetIntervalStart(const unsigned int &serialNumber) override;
    void OtherSideSendGetDateTime(const unsigned int &serialNumber) override;
    void OtherSideSendGetPirSensitivity(const unsigned int &serialNumber) override;
    void ReplyOtherSideSendIpcMission(const ASK_RESULT &result, const unsigned int &serialNumber);
    void ReplyOtherSideSendHeartBeat(const unsigned int &serialNumber);
    void ReplyOtherSideSendGetIntervalStart(const McuGetIntervalStart &interval, const unsigned int &serialNumber);
    void ReplyOtherSideSendGetDateTime(const McuReplyDateTime &time, const unsigned int &serialNumber);
    void ReplyOtherSideSendGetPirSensitivity(const unsigned char &sensitivity, const unsigned int &serialNumber);

private: // About mMcuAskList
    void AddMcuRecv(std::shared_ptr<VMcuRecv> &recv);
    void McuAskSendIpcMissionHandle(std::shared_ptr<VMcuRecv> &recv);
    void McuAskSendHeartBeatHandle(std::shared_ptr<VMcuRecv> &recv);

private:
    std::mutex mMutex;
    std::weak_ptr<VMcuMonitor> mMonitor;
    /**
     * @brief If the monitor has not been registered yet, it is necessary to cache the reported messages and report them
     * again when the monitor is registered.
     */
    std::list<std::shared_ptr<VMcuRecv>> mMcuAskList;
    std::map<OtherSideSendType, McuAskHandleFunc> mMcuAskHandle;
};
#endif