#pragma once

#include "book.hpp"

#include <chrono>
#include <cstdint>
#include <ostream>
#include <queue>
#include <unordered_map>

namespace json
{
enum MessageTypes {
	FUTURE_TYPE,
	SPREAD_TYPE,
	CALL_TYPE,
	PUT_TYPE,
	SETTLEMENT,
	ADD,
	ADDED,
	DELETE,
	DELETED,
	REJECT,
	TRADE,
	BROKER_REQUEST,
	BROKER_ACK,
	BROKER_CONFIRM,
	ERROR,
	NONE
};

enum TradeTypeEnum { BUY_AGGRESSOR, SELL_AGGRESSOR, BROKER_TRADE };

struct Message {
	MessageTypes type;
	std::string product;
	Message(MessageTypes type, std::string product);
	Message();
	virtual ~Message() = default;
};

struct ErrorMessage : public Message {
	std::string message;
	ErrorMessage(std::string message);
	std::string as_string();
};

struct FromExchange : public Message {
	uint64_t sequence;
	double timestamp;
	FromExchange(MessageTypes type, std::string product, uint64_t sequence,
	             double timestamp);
	virtual ~FromExchange() = default;
};

struct ToExchange : public Message {
	ToExchange(MessageTypes type, std::string product);
	virtual ~ToExchange() = default;
};

struct Broker : public Message {
	double price;
	book::OrderSideEnum side;
	uint64_t volume;
	std::string counterparty;
	Broker(MessageTypes type, std::string product, double price,
	       book::OrderSideEnum side, uint64_t volume, std::string counterparty);
	virtual ~Broker() = default;
};

struct AnnounceMessage : public FromExchange {
	int stationId;
	std::string stationName;
	std::string unit;
	std::chrono::nanoseconds expiry;
	double aggFee;
	double pasFee;
	double broFee;

	AnnounceMessage(MessageTypes type, std::string product, int stationId,
	                std::string stationName, std::string unit,
	                std::chrono::nanoseconds expiry, double aggFee,
	                double pasFee, double broFee, uint64_t sequence,
	                double timestamp);
};

struct SettleMessage : public FromExchange {
	std::string stationName;
	std::chrono::nanoseconds expiry;
	double price;
	SettleMessage(MessageTypes type, std::string product,
	              std::string stationName, std::chrono::nanoseconds expiry,
	              double price, uint64_t sequence, double timestamp);
};

struct AddMessage : public ToExchange {
	double price;
	book::OrderSideEnum side;
	uint64_t volume;
	AddMessage(MessageTypes type, std::string product, double price,
	           book::OrderSideEnum side, uint64_t volume);
	std::string as_string();
};

struct AddedMessage : public FromExchange {
	std::string id;
	book::OrderSideEnum side;
	double price;
	uint64_t filled;
	uint64_t resting;
	AddedMessage(MessageTypes type, std::string product, std::string id,
	             book::OrderSideEnum side, double price, uint64_t filled,
	             uint64_t resting, uint64_t sequence, double timestamp);
	std::string as_string();
};

struct DeleteMessage : public ToExchange {
	std::string id;
	DeleteMessage(MessageTypes type, std::string product, std::string id);
	std::string as_string();
};

struct DeletedMessage : public FromExchange {
	std::string id;
	book::OrderSideEnum side;
	DeletedMessage(MessageTypes type, std::string product, std::string id,
	               book::OrderSideEnum side, uint64_t sequence,
	               double timestamp);
	std::string as_string();
};

struct RejectMessage : public FromExchange {
	std::string error;
	RejectMessage(MessageTypes type, std::string product, std::string error,
	              uint64_t sequence, double timestamp);
	std::string as_string();
};

struct TradeMessage : public FromExchange {
	double price;
	uint64_t volume;
	std::string buyer;
	std::string seller;
	TradeTypeEnum tradeType;
	std::string passiveOrder;
	uint64_t passiveOrderRemaining;
	TradeMessage(MessageTypes type, std::string product, double price,
	             uint64_t volume, std::string buyer, std::string seller,
	             TradeTypeEnum tradeType, std::string passiveOrder,
	             uint64_t passiveOrderRemaining, uint64_t sequence,
	             double timestamp);
};

struct BrokerRequest : public Broker {
	BrokerRequest(MessageTypes type, std::string product, double price,
	              book::OrderSideEnum side, uint64_t volume,
	              std::string counterparty);
};

struct BrokerAck : public Broker {
	std::string id;
	std::string brokerTradeStatus;
	std::string owner;
	BrokerAck(MessageTypes type, std::string product, double price,
	          book::OrderSideEnum side, uint64_t volume,
	          std::string counterparty, std::string id,
	          std::string brokerTradeStatus, std::string owner);
};

struct BrokerConfirm : public Broker {
	std::string id;
	BrokerConfirm(MessageTypes type, std::string product, double price,
	              book::OrderSideEnum side, uint64_t volume,
	              std::string counterparty, std::string id);
};

std::queue<Message*> parse(std::string& str);
} // namespace json