#include <iostream>
#include <vector>
#include <cassert>
#include <fstream>
#include <ctime>

struct Wallet
{
	char owner[256];
	unsigned int id;
	double fiatMoney;

	Wallet(static char const owner[256], unsigned int id = -1, double fiatMoney = 0.0) : id(id), fiatMoney(fiatMoney)
	{
		//assert(strlen(owner) < sizeof(this->owner));
		strcpy_s(this->owner, owner);
		this->id = id;
		this->fiatMoney = fiatMoney;
	}
};

struct Transaction
{
	long long time;
	unsigned int senderId;
	unsigned int resiverId;
	double fmiCoints;

	Transaction(long long time = -1, unsigned int giverId = -1, unsigned int resiverId = -1, double fmiCoints = 0.0) : time(time), senderId(giverId), resiverId(resiverId), fmiCoints(fmiCoints) {};
};

struct Order
{
	enum Type { SELL, BUY } type;
	unsigned int walletId;
	double fmiCoints;

	Order(Order::Type type, unsigned int walletId, double fmiCoints) : type(type), walletId(walletId), fmiCoints(fmiCoints) {}
};

std::vector<Wallet> allWallets; //unique wallets -- maybe sort?
std::vector<Transaction> allTransactions; //All Transactions (Not Unique)
std::vector<Order> allOrders;

int findWalletById(unsigned int walletId)
{
	for (size_t i = 0; i < allWallets.size(); i++)
	{
		if (allWallets[i].id == walletId)
			return i;
	}
	return -1;
}

bool addNewWallet(const char owner[256], unsigned int walletId, double fiatMoney)
{
	int index = findWalletById(walletId);
	if (index != -1)
	{
		return false;
	}

	Wallet wallet(owner, walletId, fiatMoney);
	allWallets.push_back(wallet);
	return true;
}

void writeWalletInformation(unsigned int walletId)
{
	std::ofstream wallets("wallets.dat", std::ios::binary | std::ios::app);
	if (!wallets)
	{
		return;
	}
	else
	{
		//const int size = allWallets.size();
		//wallets.write((char*)&size, sizeof(size));
		const Wallet& wallet = allWallets[findWalletById(walletId)];
		wallets.write((char*) & (wallet.owner), sizeof(wallet.owner));
		wallets.write((char*) & (wallet.id), sizeof(wallet.id));
		wallets.write((char*) & (wallet.fiatMoney), sizeof(wallet.fiatMoney));
	}
	wallets.close();
}

void writeTransactionInformation(const Transaction& transaction)
{
	std::ofstream transactions("transactions.dat", std::ios::binary | std::ios::app);

	if (!transactions)
	{
		return;
	}
	else
	{
		transactions.write((char*) & (transaction.senderId), sizeof(transaction.senderId));
		transactions.write((char*) & (transaction.resiverId), sizeof(transaction.resiverId));
		transactions.write((char*) & (transaction.fmiCoints), sizeof(transaction.fmiCoints));
		transactions.write((char*) & (transaction.time), sizeof(transaction.time));
	}
}

bool firstTransaction(long long time, unsigned int giverId, unsigned int resiverId, double fmiCoints)
{
	int giverIndex = findWalletById(giverId);

	if (giverIndex == -1)
	{
		return false;
	}

	int receiverIndex = findWalletById(resiverId);
	if (receiverIndex == -1)
	{
		return false;
	}

	Transaction transaction(time, giverId, resiverId, fmiCoints);

	allTransactions.push_back(transaction);
	writeTransactionInformation(transaction);
	return true;
}

bool transaction(long long time, unsigned int giverId, unsigned int resiverId, double tradeMoney)
{
	int giverIndex = findWalletById(giverId);
	double coints;

	if (giverIndex == -1)
	{
		return false;
	}

	int resiverIndex = findWalletById(resiverId);
	if (resiverIndex == -1)
	{
		return false;
	}

	Wallet& giverWallet = allWallets[giverIndex];
	Wallet& resiverWallet = allWallets[resiverIndex];

	if (giverWallet.fiatMoney < tradeMoney)
	{
		return false;
	}
	else
	{
		giverWallet.fiatMoney -= tradeMoney;
		resiverWallet.fiatMoney += tradeMoney;

		coints = tradeMoney / 375.0;

		Transaction transaction(time, giverId, resiverId, coints);
		allTransactions.push_back(transaction);
		writeTransactionInformation(transaction);
		return true;
	}
}

void writeOrderInformation()
{
	std::ofstream orders("orders.dat", std::ios::binary | std::ios::trunc);

	if (!orders)
	{
		return;
	}
	else
	{
		for (size_t ic = 0; ic < allOrders.size(); ic++)
		{
			orders.write((char*) & (allOrders[ic].type), sizeof(allOrders[ic].type));
			orders.write((char*) & (allOrders[ic].walletId), sizeof(allOrders[ic].walletId));
			orders.write((char*) & (allOrders[ic].fmiCoints), sizeof(allOrders[ic].fmiCoints));
		}
	}
}

int firstSellOrder()
{
	for (size_t ib = 0; ib < allOrders.size(); ib++)
	{
		if (allOrders[ib].type == Order::Type::SELL)
		{
			return ib;
		}
	}
	return -1;
}

int firstBuyOrder()
{
	for (size_t id = 0; id < allOrders.size(); id++)
	{
		if (allOrders[id].type == Order::Type::BUY)
		{
			return id;
		}
		return -1;
	}
}

bool buyOrder(unsigned int walletId, double fiatMoney, const Order& order)
{
	int buyerIndex = findWalletById(walletId);
	double fmiCoinnts = fiatMoney / 375;
	time_t now = time(0);

	if (buyerIndex == -1)
	{
		return false;
	}

	else
	{
		//?
		if (allWallets[buyerIndex].fiatMoney < fiatMoney)
		{
			return false;
		}

		else
		{
			unsigned int senderId;
			//unsigned int receiverId = allWallets[findWalletById(walletId)].;

			int firstSellOrderIndex = firstSellOrder();
			if (firstSellOrderIndex == -1)
			{
				allOrders.push_back(order);
				writeOrderInformation();
				return true;
			}
			else
			{
				//Order popOrder = allOrders[firstSellOrderIndex];

				unsigned int senderId = allOrders[firstSellOrderIndex].walletId;
				int sellerIdIndex = findWalletById(senderId);


				allWallets[sellerIdIndex].fiatMoney += fiatMoney;
				allWallets[buyerIndex].fiatMoney -= fiatMoney;

				transaction(now, senderId, walletId, fmiCoinnts);

				for (size_t i = firstSellOrderIndex; i < allOrders.size() - 1; i++)
				{
					allOrders[i] = allOrders[i + 1];
				}

				//allOrders[allOrders.size()] = popOrder

				allOrders.pop_back();
				writeOrderInformation();
				return true;
			}
		}
	}
}

void generateOrder()
{
	return 0;
}

bool sellOrder(unsigned int walletId, double fiatMoney, const Order& order)
{
	int sellerIndex = findWalletById(walletId);
	double fmiCoinnts = fiatMoney / 375;
	time_t now = time(0);

	if (sellerIndex == -1)
	{
		return false;
	}
	else
	{
		if (allWallets[sellerIndex].fiatMoney < fiatMoney)
		{
			return false;
		}
		else
		{
			unsigned int recieverId;

			int firstBuyOrderIndex = firstBuyOrder();

			if (firstBuyOrderIndex == -1)
			{
				allOrders.push_back(order);
				writeOrderInformation();
				return true;
			}
			else
			{
				unsigned int buyerIndex = allOrders[firstBuyOrderIndex].walletId;
				int buyerIdIndex = findWalletById(buyerIndex);


				allWallets[sellerIndex].fiatMoney -= fiatMoney;
				allWallets[buyerIdIndex].fiatMoney += fiatMoney;

				generateOrder();

				Transaction trans();
				transaction(now, walletId, buyerIndex, fiatMoney);

				for (size_t i = firstBuyOrderIndex; i < allOrders.size() - 1; i++)
				{
					allOrders[i] = allOrders[i + 1];
				}

				//allOrders[allOrders.size()] = popOrder

				allOrders.pop_back();
				writeOrderInformation();
				return true;
			}
		}
	}
}

int main()
{
	std::string command;

	time_t now = time(0);

	char systemWalletName[256] = "System Name";
	unsigned int systemWalletId = 4294967295;
	double systemWalletSystemFiatMoney = 112121212121212.0;

	Wallet systemWallet(systemWalletName, systemWalletId, systemWalletSystemFiatMoney);
	allWallets.push_back(systemWallet);

	while (true)
	{
		std::cout << "Please enter your command: " << std::endl;
		std::cin >> command;

		if (command == "add-wallet")
		{
			char ownerName[256];
			unsigned int walletId;
			double fiatMoney;
			std::cout << "Enter the owner name, wallet id and fiat money" << std::endl;
			std::cin >> ownerName >> walletId >> fiatMoney;
			if (addNewWallet(ownerName, walletId, fiatMoney))
			{
				double coints = fiatMoney / 375.0;
				writeWalletInformation(walletId);
				std::cout << "Successfully added wallet to wallet list!" << std::endl;
				firstTransaction(now, systemWallet.id, walletId, coints);
			}
			else
			{
				std::cout << "Not Successfully added wallet!" << std::endl;
			}
		}

		else if (command == "transaction")
		{

			char ownerName[256];
			unsigned int giverWalletId, receicerWalletId;
			double tradeMoney;
			std::cout << "Enter the senderId, resiverId, tradeMoney" << std::endl;
			std::cin >> giverWalletId >> receicerWalletId >> tradeMoney;

			//unsigned int giverId, receiverId;
			//time_t now = time(0);

			if (transaction(now, giverWalletId, receicerWalletId, tradeMoney))
			{
				std::cout << "Transaction successfully created" << std::endl;
			}
			else
				std::cout << "Transaction not successfully created" << std::endl;
		}

		else if (command == "transfer")
		{
			std::cout << "Please ender sender sender id and receiver id and transfer coints: " << std::endl;
			unsigned int senderId, receiverId;
			double transferCoints;
			std::cin >> senderId >> receiverId >> transferCoints;

			double transferFiatMoney = transferCoints * 375.0;

			if (transaction(now, senderId, receiverId, transferFiatMoney))
			{
				std::cout << "Successfully transfer fmi coints" << std::endl;
			}
			else
			{
				std::cout << "Failed to transfer fmi coints" << std::endl;
			}
		}

		else if (command == "make-order")
		{
			std::cout << "Please enter the order(SELL or BUY), wallet id and the coits for that operation" << std::endl;

			char order[16];
			unsigned int walletId;
			double fmiCoints;
			std::cin >> order >> walletId >> fmiCoints;

			double fiatMoney = fmiCoints * 375;

			if (order == "BUY")
			{
				Order newOrder(Order::BUY, walletId, fmiCoints);
				if (buyOrder(walletId, fiatMoney, newOrder))
				{
					std::cout << "Successfully compleated order and created transaction!" << std::endl;
				}
				else
				{
					std::cout << "Failed by creating new buy order!" << std::endl;
				}
			}
			else if (order == "SELL")
			{
				Order newOrder(Order::SELL, walletId, fmiCoints);
				if (sellOrder(walletId, fiatMoney, newOrder))
				{
					std::cout << "Successfully compleated order!" << std::endl;
				}
				else
				{
					std::cout << "Failed by creating new sell order!" << std::endl;
				}
			}
			else
			{
				std::cout << "Unvalid order" << std::endl;
			}
		}

		else if (command == "quit")
		{
			return 0;
		}
	}
}