#pragma once

#include "Bucket.hh"
#include "../peripheral/IMemoryAccess.hh"
#include "../memories/memories.hh"
#include "../common/Crc.hpp"
#include "../systemic/Timer.hh"
#include "MemoryOperationExecutor.hh"

#include "Delegate.hh"

#include <utility>
#include <queue>

namespace logging {

struct StorageReadInterface {

    enum PrefetchResult {
        IDLE_STATE = 0,
        COMPLETE = 1,
        IN_PROGRESS = 2,
        ERROR = -1,
        OUT_OF_BOUND = -2
    };

    typedef uint16_t prefetch_result;
    typedef int16_t BlockId;
    typedef std::pair<const char *, std::size_t> DataBlock;

    typedef uint32_t PowerOnNumber;

    virtual std::pair<PrefetchResult, DataBlock> prefetch_block( BlockId ) = 0;

    virtual std::size_t blocks_count() = 0;
    virtual std::size_t block_size() = 0;

    virtual PowerOnNumber power_on() const = 0;
    virtual bool storage_ready() const = 0;

};

class StorageManager : public StorageReadInterface {
public:
    void process();

    StorageManager( peripheral::IMemoryAccess &, std::pmr::memory_resource &, bool = true );

    /* Настроить период синхронизации данных во временной и постоянной памяти.*/
    void set_cache_synchronize_period( unsigned long long );

    /* Передать данные на хранение.*/
    bool commit( const char *, size_t length );

    std::pair<PrefetchResult, DataBlock> prefetch_block( BlockId block_id );
    DataBlock read_buffered_block();

    void read_block_async( size_t, prefetch_result &, const char *, size_t & );
    void get_block_hash_async( size_t, prefetch_result &, uint32_t & );

    PowerOnNumber power_on() const;
    bool storage_ready() const;

    size_t blocks_count();
    size_t allocated_bytes();
    size_t block_size();

    void flush_local();

private:
    enum CONSTEXPR {
        MAGICK_KEY = 0xABABABAB,
        DEFAULT_SYNC_PERIOD = 1000
    };

    enum MEMORY_ADDRESSING {
        INFOHEADER_BASE = 0x0,
    };


    unsigned long long sync_buffer_period = DEFAULT_SYNC_PERIOD;  // Инвервал времени между синхронизациями хранилища в ОП и ПП.
    
    enum BLOCK_WRITE_OPERATION {
        NOPE,
        SYNC,
        INSERT_AND_MOVE,
    };

    enum BLOCK_LOAD_OPERATION {
        NO_LOAD,
        LOAD_CONTROL,
        LOAD_INFO,
        INIT_BACKET
    };

    BLOCK_WRITE_OPERATION block_write_op;
    BLOCK_LOAD_OPERATION block_load_op;

    struct FetchParametes {
        BlockId    block  = -1;
        PrefetchResult result = IDLE_STATE;
    };

    FetchParametes fetch_parameters;

    struct ControlBlock {

        uint32_t magick_key;
        uint16_t bucket_size;
        uint16_t coursor;
        uint32_t check_summ;
        PowerOnNumber number_of_power_on;

        ControlBlock() : magick_key(MAGICK_KEY), bucket_size(0), coursor(0), check_summ(0), number_of_power_on(1) {}

    };

    MemoryOperationExecutor mem_op_exec;
    ControlBlock control_block;

    const peripheral::IMemoryAccess & memory;

    std::pmr::memory_resource * allocator;

    systemic::Timer sync_timer;

    bool information_block_is_dirty = false;
    bool drop_buffer_to_storage     = false;

    bool finish_commit;

    bool auto_cache_sync;


    bool buffer_in_ready;

    Bucket buffer_in;
    Bucket buffer_out;

    Delegate feedback_load_block;
    Delegate feedback_write_bckt;

    Delegate feedback_init_backet;

    const size_t blocks_limit;

    void on_load_block( MemoryOperationExecutor::OPERATION_RESULT res );
    void on_write_block( MemoryOperationExecutor::OPERATION_RESULT res );
    
    void on_init_backet( MemoryOperationExecutor::OPERATION_RESULT res );
    void init_backet();

    /* Асинхронная подгрузка информационного заголовка в оперативную память.*/
    void load_control_block();

    /* Синхронизировать блок управления в оперативной памяти и ПЗУ. */
    void sync_control_block();
    void mux_block_operation(BLOCK_WRITE_OPERATION);
    void send_block();

    void load_block( BlockId block_id );

    size_t in_memory_placement( BlockId block_id );

};

}