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

    File: FileSeekableWriter.hpp
    Date: 2024-2-25
    Author: Reece
***/
#pragma once

namespace Aurora::IO::FS
{
    struct FileSeekableWriter : ISeekingWriter
    {
        AU_NO_COPY_NO_MOVE(FileSeekableWriter)

        inline FileSeekableWriter() {}
        inline FileSeekableWriter(const AuSPtr<IFileStream> &stream) : stream_(stream) { }
        inline ~FileSeekableWriter() {}
        
        template<typename... T>
        bool OpenFile(T... args)
        {
            this->stream_ = OpenWriteShared(args...);
            return bool(this->stream_);
        }

        virtual EStreamError IsOpen() override
        {
            return this->stream_ ? EStreamError::eErrorNone : EStreamError::eErrorStreamInterrupted;
        }

        virtual EStreamError ArbitraryWrite(AuUInt offset, const Memory::MemoryViewStreamRead &paramters) override
        {
            if (!this->stream_)
            {
                return EStreamError::eErrorStreamNotOpen;
            }

            if (!this->stream_->SetOffset(offset))
            {
                return EStreamError::eErrorEndOfStream;
            }

            if (!this->stream_->Write(paramters))
            {
                return EStreamError::eErrorStreamInterrupted;
            }

            if (paramters.outVariable == 0)
            {
                return EStreamError::eErrorEndOfStream;
            }

            return EStreamError::eErrorNone;
        }

        virtual void Flush() override
        {
            if (this->stream_)
            {
                this->stream_->Flush();
            }
        }

        virtual void Close() override
        {
            this->stream_.reset();
        }

    private:
        AuSPtr<IFileStream> stream_{};
    };
}