/***
    Copyright (C) 2022 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: IOProcessor.hpp
    Date: 2022-6-6
    Author: Reece
***/
#pragma once

#include "AuIOPipeProcessor.hpp"
#include "AuIOProcessorItems.hpp"
#include "AuIOProcessorTimers.hpp"

namespace Aurora::IO
{
    struct IOProcessor : IIOProcessor, AuEnableSharedFromThis<IOProcessor>, AuAsync::IWorkItemHandler
    {
        ~IOProcessor();
        IOProcessor(AuUInt threadId, bool tickOnly, AuAsync::WorkerPId_t worker, const AuSPtr<AuLoop::ILoopQueue> &loop, bool bIsNoQueue);

        bool Init();

        bool QueueIOEvent(const AuSPtr<IIOProcessorItem> &ioEvent);

        void FrameRunIOWorkUnits();

        AuUInt32 TryTick() override;
        AuUInt32 RunTick() override;
        AuUInt32 RunTickEx(AuUInt32 dwTimeout) override;
        AuUInt32 TickFor(const AuSPtr<IIOProcessorItem> &ioEvent) override;
        bool TickForRegister(const AuSPtr<IIOProcessorItem> &ioEvent);

        void TickForHack(const AuSPtr<IIOProcessorItem> &ioEvent);
        bool bScheduled_ {};
        AuUInt32 ManualTick() override;

        void DispatchFrame(ProcessInfo &info) override;

        bool SubmitIOWorkItem(const AuSPtr<IIOProcessorWorkUnit> &work) override;

        bool AddEventListener(const AuSPtr<IIOProcessorEventListener> &eventListener) override;
        void RemoveEventListener(const AuSPtr<IIOProcessorEventListener> &eventListener) override;

        void FrameStart(); 
        void FramePumpWaitingBlocked();
        bool FrameWaitForAny(AuUInt32 msMax);
        AuUInt FrameRunEpilogue();
        void FrameRunThreadIO();
        void FrameRunCheckLSes();
        void FrameRunAlerted();
        void FrameRunAlertedSniffers();
        void FrameEndOfFrameEvents();
        AuUInt FrameFinalize();


        bool InternalIsTickReady();

        void ClearProcessor(const AuSPtr<IOProcessorItem> &processor, bool fatal);

        void ReportState(EIOProcessorEventStage stage);

        AuUInt64 SetRefreshRate(AuUInt64 ns) override;
        bool HasRefreshRate() override;

        AuUInt64 GetOwnedThreadId() override;

        bool MultiplexRefreshRateWithIOEvents() override;

        AuSPtr<IIOProcessorItem> StartIOWatch(const AuSPtr<IIOWaitableItem> &object, const AuSPtr<IIOEventListener> &listener) override;
        AuSPtr<IIOProcessorItem> StartSimpleIOWatch(const AuSPtr<IIOWaitableItem> &object, const AuSPtr<IIOSimpleEventListener> &listener) override;
        AuSPtr<IIOProcessorItem> StartSimpleLSWatch(const AuSPtr<Loop::ILoopSource> &source, const AuSPtr<IIOSimpleEventListener> &listener) override;

        AuSPtr<IIOProcessorItem> StartIOWatchEx      (const AuSPtr<IIOWaitableItem> &object, const AuSPtr<IIOEventListener> &listener, bool singleshot) override;
        AuSPtr<IIOProcessorItem> StartSimpleIOWatchEx(const AuSPtr<IIOWaitableItem>& object, const AuSPtr<IIOSimpleEventListener>& listener, bool singleshot) override;
        AuSPtr<IIOProcessorItem> StartSimpleLSWatchEx(const AuSPtr<Loop::ILoopSource>& source, const AuSPtr<IIOSimpleEventListener>& listener, bool singleshot, AuUInt32 msTimeout) override;


        AuSPtr<IIOPipeProcessor> ToPipeProcessor() override;

        AuSPtr<AuLoop::ILoopQueue> ToQueue() override;
        void ReleaseAllWatches() override;

        bool HasItems() override;
        
        void WakeupThread();

        bool CheckThread();

        bool RequestRemovalForItemFromAnyThread(const AuSPtr<IIOProcessorItem> &processor);

        AuSPtr<AuLoop::ILoopQueue> pLoopQueue;

        AuUInt threadId;

        AuUInt64 refreshRateNs {};
        AuUInt64 minFrameDeltaNs {};
        bool bIsNoQueue;

        void UpdateTimers();

        void AddTimer();
        void AddTimerLS();
        void StartAsyncTimerIfAny();
        void RemoveTimer();

        void CancelWorkItem();
        void RemoveLSTimer();

        bool IsTickOnly();
        bool IsAsync();

        bool mutliplexIOAndTimer {true};

        IOProcessorItems items;
        IOProcessorTimers timers;
        AuAsync::WorkerPId_t asyncWorker;
        AuSPtr<AuAsync::IWorkItem> pWorkItem;

        AuThreadPrimitives::MutexUnique_t mutex;

        AuThreadPrimitives::SpinLock listenersSpinLock;
        AuList<AuSPtr<IIOProcessorEventListener>> listeners;

        AuList<AuSPtr<IIOProcessorWorkUnit>> workUnits;

        IOPipeProcessor streamProcessors;

        bool bFrameStart {};
    };
}