#pragma once

#include <pipes/buffer.h>
#include <functional>
#include <memory>
#include <event.h>

namespace ts {
    namespace server {
        class VirtualServer;
    }

    namespace weblist {
        class TSWebClient {
            public:
                enum State {
                    S_UNINITIALIZED,
                    S_INITIALIZING,
                    S_DATA_EXCHANGE,
                    S_FINALIZING,
                    S_FINALIZED
                };

                TSWebClient(const std::shared_ptr <server::VirtualServer> &server, struct event_base *event_base, uint16_t session_index, bool /* resend name */);
                virtual ~TSWebClient();

                void report();
                void abort();
                void abort_sync();
                inline bool running() { return this->state != S_FINALIZED && this->state != S_UNINITIALIZED; }

                std::function<void(const std::string&, bool)> callback_error;
                std::function<void()> callback_success;
            private:
                std::shared_ptr<server::VirtualServer> server;
                struct event_base* event_base = nullptr;
                std::thread close_thread;
                State state;

                sockaddr_in remote_address{};
                std::mutex write_lock;
                std::deque<pipes::buffer> write_buffer{};
                int file_descriptor{0};

                struct event* event_read = nullptr;
                struct event* event_write = nullptr;
                struct event* event_timeout = nullptr;

                void unregister_events(bool /* blocking */);
                void reset_timeout(bool /* reschedule */);

                static void _handle_message_read(int, short, void*);
                static void _handle_message_write(int, short, void*);
                static void _handle_timeout(int, short,void*);

                void trigger_fail_later(const std::string& /* message */, bool /* retry */);
                void trigger_success_later();

                void write_message(const pipes::buffer_view& /* buffer */);

            private:
                void handle_message_read(const pipes::buffer_view& /* buffer */);

                uint16_t session_index = 1;
                uint32_t session_id = 0;
                bool send_name = false;

                void request_session();
                void send_status(bool /* name */);
        };
    }
}