AuroraRuntime/Include/Aurora/IO/IOHandle.hpp

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

    File: IOHandle.hpp
    Date: 2023-7-28
    Author: Reece
***/
#pragma once

#include "FS/EFileAdvisoryLockLevel.hpp"
#include "FS/EFileOpenMode.hpp"

namespace Aurora::IO
{
    // Note: A handle is never disposable to prevent IO fd use after close
    //       You must ensure RAII and/or shared ownership release to dispose of the IO handle.
    //       This class is only intended to be an handle view; therefore, it is not possible to close the handle.
    // 
    // You should use the AuIOHandle or AuIO::IOHandle aliases for construction
    struct IIOHandle
    {
        struct HandleCreate
        {
            /**
             * "Create"
             */
            bool bFailIfNonEmptyFile {};
            
            /**
             * Lock level
             */
            FS::EFileAdvisoryLockLevel eAdvisoryLevel;
            
            /**
             * Path
             */
            const AuString &path;
            
            /**
             * Mode
             */
            FS::EFileOpenMode eMode;

            /**
             * 
             */
            bool bAlwaysCreateDirTree { true };

            /**
             * Indicates the handle will be for use with IAsyncTransactions as opposed to IFileStream and AuProcess
             */
            bool bAsyncHandle  { false };

            /**
             * Indicates the handle will only ever directly interface with the disk hardware as opposed to leveraging kernel assigned user shared memory
             */
            bool bDirectIOMode { false };
            
            cstatic HandleCreate Create(const AuString &path)
            {
                HandleCreate create(path);
                create.bFailIfNonEmptyFile = true;
                create.eMode = FS::EFileOpenMode::eReadWrite;
                create.eAdvisoryLevel = FS::EFileAdvisoryLockLevel::eBlockReadWrite;
                return AuMove(create);
            }
                        
            cstatic HandleCreate ReadWrite(const AuString &path)
            {
                HandleCreate create(path);
                create.eMode = FS::EFileOpenMode::eReadWrite;
                create.eAdvisoryLevel = FS::EFileAdvisoryLockLevel::eBlockReadWrite;
                return AuMove(create);
            }
            
            cstatic HandleCreate Read(const AuString &path)
            {
                HandleCreate read(path);
                read.eMode = FS::EFileOpenMode::eRead;
                read.eAdvisoryLevel = FS::EFileAdvisoryLockLevel::eBlockWrite;
                return AuMove(read);
            }
            
            cstatic HandleCreate Open(const AuString &path)
            {
                HandleCreate read(path);
                read.eMode = FS::EFileOpenMode::eRead;
                read.eAdvisoryLevel = FS::EFileAdvisoryLockLevel::eBlockReadWrite;
                return AuMove(read);
            }
            
            inline HandleCreate(const AuString &path) :
                path(path)
            {
            }
        };

        virtual bool InitFromHandle(AuSPtr<IIOHandle> pHandle) = 0;
        
        virtual bool InitFromPath(HandleCreate create) = 0;

        virtual bool InitFromCopy(AuUInt64 uOSHandle) = 0;

        virtual bool InitFromMove(AuUInt64 uOSHandle) = 0;

        virtual bool InitFromPair(AuOptionalEx<AuUInt64> optOSReadHandle,
                                  AuOptionalEx<AuUInt64> optOSWriteHandle) = 0;

        virtual bool InitFromPairMove(AuOptionalEx<AuUInt64> optOSReadHandle,
                                      AuOptionalEx<AuUInt64> optOSWriteHandle) = 0;

        virtual bool InitFromStreamEnum(EStandardStream eStream) = 0;

        virtual bool InitFromSharing(const AuString &handle) = 0;

        virtual AuUInt64 GetOSHandle() const = 0;

        virtual AuOptionalEx<AuUInt64> GetOSHandleSafe() const = 0;

        virtual AuUInt64 GetOSReadHandle() const = 0;

        virtual AuOptionalEx<AuUInt64> GetOSReadHandleSafe() const = 0;

        virtual AuUInt64 GetOSWriteHandle() const = 0;

        virtual AuOptionalEx<AuUInt64> GetOSWriteHandleSafe() const = 0;

        virtual bool IsValid() const = 0;

        virtual bool HasUniqueWriteHandle() const = 0;

        virtual bool IsAsync() const = 0;

        virtual AuString GetPath() const = 0;

        virtual bool IsFlushOnClose() const = 0;
        
        virtual void SetFlushOnClose(bool bFlushOnClose) = 0;

        virtual bool IsFile() const = 0;

        virtual bool IsTTY() const = 0;

        virtual bool IsPipe() const = 0;

        virtual bool SectionLock(AuUInt64 uOffset,
                                 AuUInt64 uLength,
                                 FS::EFileAdvisoryLockLevel level) = 0;

        virtual bool SectionUnlock(AuUInt64 uOffset,
                                   AuUInt64 uLength) = 0;

        virtual AuString SharingGetString() = 0;

        virtual bool SharingIsShared() = 0;

        virtual void SharingStop() = 0;
    };
    
    AUKN_SHARED_SOO_CC(IOHandle, IIOHandle, 256);

    AUKN_SYM bool IsHandleTTY(AuUInt uHandle);

    AUKN_SYM bool IsHandlePipe(AuUInt uHandle);

    AUKN_SYM bool IsHandleFile(AuUInt uHandle);
}