#include "config.h"

#include <vector>
#include <set>
#include <map>
#include <queue>

#include <boost/thread/detail/config.hpp>
#include <boost/thread/thread.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include <boost/smart_ptr.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>


#include "tcpSocket.h"
#include "stock.h"
#include "request.h"

namespace StockMarket
{
	recursive_mutex req_queue_mutex;

	uint Request::seq_id = 1;
	bool Request::received = true;
	Request::Request() : first(true)
	{}
	Request::operator bool ()
	{
		if(first) 
		{
			first = false;
			return true;
		}
		else
		{
			return false;
		}
	}
	void Request::res_seq_id(uint id)
	{
		// 只有收到較后面的時(shí)候，才設(shè)置新值
		// ( 考慮到有些時(shí)候收發(fā)的順序不同)
		if(id >= seq_id || id == 0)		// id == 0 rewind
		{
			seq_id = id;
			received = true;
		}
	}
	bool Request::ready()
	{
		static uint cnt = 0;
		if(!received)
		{
			if((++cnt) % 20 == 0)	// 等待 30 個(gè)周期還沒有收到response，則重發(fā)
			{
				++seq_id;
				return true;
			}
		}
		else
		{
			cnt = 1;
		}
		return received;
	}
	void Request::next()
	{
		if(received)
		{
			this->operator ++();
			++seq_id;
		}
	}
	Request& Request::operator++()
	{
		return *this;
	}
	void Request::send(TcpSocket& soc)
	{
		ReqHead* pHead = (ReqHead*)buff();
		pHead->set_seq_id(seq_id);
		soc.SendBuf(buff(), len());
		received = false;
	}
	Request::~Request(){}

	ReqHead::ReqHead( ushort cmd_id, ushort packet_len/*the total packet len*/ = 0)
	{
		zip = 0x0c;
		seq_id = 0;
		packet_type = 1;
		len = len1 = packet_len - sizeof(ReqHead) + 2;
		cmd = cmd_id;
	}
	uint ReqHead::get_seq_id()
	{
		return seq_id;
	}
	void ReqHead::set_seq_id(uint id)
	{
		seq_id = id;
	}
	void ReqHead::set_len(ushort payload_len)
	{
		len = len1 = payload_len;
	}
	ushort ReqHead::get_len()
	{
		return len;
	}

	char* StockHeartBeat::buff()
	{
		return (char*)&s;
	}
	ulong StockHeartBeat::len()
	{
		return sizeof(StockHeartBeatStruct);
	}
	
	StockListReq::StockListReq(MarketInfo::MarketType market_code, ushort record_offset
		, ushort record_count, ushort record_total)
		: s(market_code, record_offset, record_count), total(record_total)
	{
		if(0 == record_total)
		{
			total = record_count;
		}
	}
	char* StockListReq::buff()
	{
		return (char*)&s;
	}
	ulong StockListReq::len()
	{
		return sizeof(StockListStruct);
	}
	
	StockListReq::operator bool ()
	{
		return s.offset < total;
	}
	StockListReq& StockListReq::operator ++ ()
	{
		if(s.offset + s.count < total)
		{
			s.offset = s.offset + s.count ;
			s.count = (total - s.offset) > s.count ? s.count : (total - s.offset);
		}
		else
		{
			s.offset = total;
		}
		return *this;
	}

	char* StockHoldChgReq::buff()
	{
		return (char*)&s;
	}
	ulong StockHoldChgReq::len()
	{
		return sizeof(ReqHead) + sizeof(ushort) + sizeof(StockHoldStruct) * s.count;
	}
	bool StockHoldChgReq::add_stock(const string& stock_code)
	{
		return s.add_one_stock(stock_code);
	}

}