//---------------------------------------------------------------------------
#include <string.h>
#include "PolicyUnit.h"
#include "GlobalUnit.h"

#pragma hdrstop

//---------------------------------------------------------------------------
#pragma package(smart_init)
/////////////////////////////////////////////////////////////////////////////
//内置策略
#define SYSBPNUM   28
char *sysBet[SYSBPNUM]  = {  //kk|p
				   "01-珠盘专打庄\n000\na,a;s,a;d,a"
				  ,"02-珠盘专打闲\n000\na,s;s,s;d,s"
				  ,"03-珠盘打连\n000\na,a;s,s;d,x"
				  ,"04-珠盘打反\n000\na,s;s,a;d,x"
				  ,"05-珠盘粘庄闲\n000\na,a;s,s;aD,a;sD,s"
				  ,"06-两闲一庄打闲\n000\nas2a,s"
				  ,"07-两庄一闲打庄\n000\nsa2s,a"
				  ,"08-大路打连\n001\nA,a;S,s"
				  ,"09-大路打断\n001\nA,s;S,a"
				  ,"10-大路逢断打反\n001\nAs,a;Sa,s"
				  ,"11-大路连二打反\n001\ns2,a;a2,s"
				  ,"12-大路连三打反\n001\ns3,a;a3,s"
				  ,"13-大路逢断打连\n001\nAs,s;Sa,a"
				  ,"14-大路跳二打连\n001\nsa,a;as,s"
				  ,"15-大路跳三打连\n001\nsas,s;asa,a"
				  ,"16-大路三打二\n001\nSas,s;Asa,a;A2s,a;S2a,s;AS2,s;SA2,a;A3,a;S3,s"
				  ,"17-大眼路打红\n002\nA,a;S,a"
				  ,"18-大眼路打蓝\n002\nA,s;S,s"
				  ,"19-大眼路逢连打连\n002\nA2,a;S2,s"
				  ,"20-大眼路逢连打断\n002\nA2,s;S2,a"
				  ,"21-小路打红\n003\nA,a;S,a"
				  ,"22-小路打蓝\n003\nA,s;S,s"
				  ,"23-小路二夹一打断\n003\na2sa2,s;s2as2,a"
				  ,"24-小强路打红\n004\nA,a;S,a"
				  ,"25-小强路打蓝\n004\nA,s;S,s"
				  ,"26-小强路背靠背打断\n004\ns2a2,s;a2s2,a;s3a3,s;a3s3,a;s4a4,s;a4s4,a;s5a5,s;a5s5,a;s6a6,s;a6s6,a"
				  ,"27-庄闲问路\n024"
				  ,"28-庄闲差\n030"
				  };

#define SYSCPNUM  10
char *sysChip[SYSCPNUM] = {//kk|pppp  pause|dead
				   "01-平注\n0000\n1,1,1"
				  ,"02-输增赢减\n0000\n1,1,2;2,1,3;3,2,4;4,3,5;5,4,6;6,5,7;7,6,8;8,7,0"
				  ,"03-输倍增赢回基\n0001\n1,1,2;2,1,3;4,1,4;8,1,5;16,1,0"
				  ,"04-层级-7手4层\n01123\n1,7,1,2;1,7,1,3;1,7,1,4;1,7,1,0"
				  ,"05-任意赢两手回基\n0012\n2,2,3;2,1,4;2,4,5;3,1,6;3,6,7;4,1,8;4,8,9;5,1,10;5,10,11;8,1,12;8,12,13;10,1,14;10,14,0;20,1,0"
				  ,"06-随机注码\n08"
				  ,"07-阶梯-4级\n02000\n1,500,1,500,2;2,500,1,500,3;3,1000,1,500,4;4,1500,1,500,0"
				  ,"08-组合阶梯-3级\n03200\n1,20,500,1,500,2;2,20,500,1,500,3;3,20,1000,1,500,0"
				  ,"09-赢输次差-单3\n04020\n1,10,2,-10,3;0,20,0,11,1;2,-11,1,-30,0"
				  ,"10-赢输次差-总4\n04021\n1,20,2,-20,3;0,40,0,20,1;2,-20,1,-40,4;4,-40,3,-60,0"
				  };


int u_iUserBetId = 100,
	u_iUserChipId = 100;
/////////////////////////////////////////////////////////////////////////////
//TBasePolicy
TBasePolicy::~TBasePolicy()
{
    Clear();
}
//---------------------------------------------------------------------------
void TBasePolicy::Clear()
{
    for(int i=0; i<aRows.size(); i++)
        delete aRows[i];
    aRows.clear();
}
//---------------------------------------------------------------------------
void TBasePolicy::Reset()
{
    Clear();
    name = "";
	type = 0;
	id = 0;
}
//---------------------------------------------------------------------------
int TBasePolicy::ParsePolicy(char* data, int pt)
{
    int iRow = 0;

    char tmp[1024];
    const char* delim = ";";
    char *token = data;
    while(*token) {
        size_t len = strcspn(token, delim);
        if(!len) break;

        strncpy(tmp, token, len), tmp[len]=0;

        int err = 0;
        TBaseRow* pRow = ParseRow(tmp, err);
        if(!pRow){
            return err + ((iRow+1)<<16);
        }

		if(pt==TYPE_P_CHIP)
			((TChipRow*)pRow)->iSeq = iRow+1;

        aRows.push_back(pRow);

		iRow++;
		token += len;
        if(*token) token++;
    }

    if(*token){
        return (iRow + 1)<<16;
    }

    return 0;
}
/////////////////////////////////////////////////////////////////////////////
//TChipPolicy
TBaseRow* TChipPolicy::ParseRow(char* data, int& err)
{
    int iCol=0,
		col[8] = {0};

    char tmp[1024];
    const char* delim = ",";
    char *token = data;
    while(*token) {
        size_t len = strcspn(token, delim);
        if(!len) break;

        strncpy(tmp, token, len), tmp[len]=0;

        sscanf(tmp, "%d", &col[iCol]);
		if(col[iCol]<0 && (iCol!=1 && iCol!=3 || kind!=KIND_CHIP_WLD ))
			break;

        iCol++;
        token += len;
        if(*token) token++;
    }

    if(*token){
        err = iCol + 1;
        return NULL;
    }

	TChipRow* pRow = kind==KIND_CHIP_HAN ? new TTierRow
					: kind==KIND_CHIP_LEV || kind==KIND_CHIP_WLD ? new TLevelRow
					: kind==KIND_CHIP_COM ? new TComboRow
					: new TChipRow;
	if(kind==KIND_CHIP_COM){
		((TComboRow*)pRow)->id = col[0];
		pRow->chip = col[1];
		((TComboRow*)pRow)->nCondWin = col[2];
		pRow->iWin = col[3];
		((TComboRow*)pRow)->nCondLos = col[4];
		pRow->iLos = col[5];
	}
	else{
		pRow->chip = col[0];

		if(kind==KIND_CHIP_HAN){
			((TTierRow*)pRow)->hands = col[1];
			pRow->iWin = col[2];
			pRow->iLos = col[3];
		}
		else if(kind==KIND_CHIP_LEV || kind==KIND_CHIP_WLD){
			((TLevelRow*)pRow)->nCondWin = col[1];
			pRow->iWin = col[2];
			((TLevelRow*)pRow)->nCondLos = col[3];
			pRow->iLos = col[4];
		}
		else{
			pRow->iWin = col[1];
			pRow->iLos = col[2];
		}
	}

	return pRow;
}
//---------------------------------------------------------------------------
TChipPolicy& TChipPolicy::operator = (const TChipPolicy& b)
{
	if (this != &b) {
		Reset();

		name = b.name;
		type = b.type;
		kind = b.kind;
		id = b.id;
		actived = b.actived;

		if(kind<=KIND_CHIP_WLD){
			dead = b.dead;
			deadPause = b.deadPause;

			if(kind==KIND_CHIP_HAN){
				((TTierPolicy*)this)->bTierWinRet = ((TTierPolicy&)b).bTierWinRet;
				((TTierPolicy*)this)->bTierAccChip = ((TTierPolicy&)b).bTierAccChip;
				((TTierPolicy*)this)->bTierLos0 = ((TTierPolicy&)b).bTierLos0;
			}
			else if(kind>=KIND_CHIP_LEV){
				((TLevelPolicy*)this)->bTotalDiff = ((TLevelPolicy&)b).bTotalDiff;
				((TLevelPolicy*)this)->bInstant = ((TLevelPolicy&)b).bInstant;

				if(kind==KIND_CHIP_WLD)
					((TWLDiffPolicy*)this)->bIndie = ((TWLDiffPolicy&)b).bIndie;
			}

			for(int i=0; i<b.aRows.size(); i++){
				TChipRow* row = kind==KIND_CHIP_HAN ? new TTierRow
								: kind==KIND_CHIP_LEV || kind==KIND_CHIP_WLD ? new TLevelRow
								: kind==KIND_CHIP_COM ? new TComboRow
								: new TChipRow;
				memcpy(row, b.aRows[i], kind==KIND_CHIP_HAN ? sizeof(TTierRow)
								: kind==KIND_CHIP_LEV || kind==KIND_CHIP_WLD ? sizeof(TLevelRow)
								: kind==KIND_CHIP_COM ? sizeof(TComboRow)
								: sizeof(TChipRow));
				aRows.push_back(row);
			}
		}
	}

	return *this;
}
//---------------------------------------------------------------------------
bool TChipPolicy::operator == (const TChipPolicy& b)
{
	if(id!=b.id || kind!=b.kind	|| aRows.size()!=b.aRows.size())
		return false;

	if(kind<=KIND_CHIP_WLD){
		if(dead!=b.dead || deadPause!=b.deadPause)
			return false;

		if(kind==KIND_CHIP_HAN){
			if(((TTierPolicy*)this)->bTierWinRet!=((TTierPolicy&)b).bTierWinRet
						|| ((TTierPolicy*)this)->bTierAccChip!=((TTierPolicy&)b).bTierAccChip
						|| ((TTierPolicy*)this)->bTierLos0!=((TTierPolicy&)b).bTierLos0)
				return false;
		}
		else if(kind>=KIND_CHIP_LEV){
			if(((TLevelPolicy*)this)->bTotalDiff!=((TLevelPolicy&)b).bTotalDiff
						|| ((TLevelPolicy*)this)->bInstant!=((TLevelPolicy&)b).bInstant)
				return false;

			if(kind==KIND_CHIP_WLD){
				if(((TWLDiffPolicy*)this)->bIndie!=((TWLDiffPolicy&)b).bIndie)
					return false;
			}
		}

		for(int i=0; i<aRows.size(); i++){
			if(memcmp(aRows[i], b.aRows[i], kind==KIND_CHIP_HAN ? sizeof(TTierRow)
											: kind==KIND_CHIP_LEV || kind==KIND_CHIP_WLD ? sizeof(TLevelRow)
											: kind==KIND_CHIP_COM ? sizeof(TComboRow)
											: sizeof(TChipRow)))
				return false;
		}
	}

	return true;
}
//---------------------------------------------------------------------------
void TChipPolicy::AddNewRow()
{
	TChipRow* row = kind==KIND_CHIP_HAN ? new TTierRow
					: kind==KIND_CHIP_LEV || kind==KIND_CHIP_WLD ? new TLevelRow
					: kind==KIND_CHIP_COM ? new TComboRow
					: new TChipRow;
    aRows.push_back(row);
}
/////////////////////////////////////////////////////////////////////////////
//TBetPolicy
void TBetPolicy::Reset()
{
    TBasePolicy::Reset();

    road = 0;
}
//---------------------------------------------------------------------------
TBaseRow* TBetPolicy::ParseRow(char* data, int& err)
{
    int iCol=0;
	vector<int> cond;
	vector<char> bets;
//	int bet;

	char tmp[1024];
	const char* delim = ",";
	char *token = data;
	while(*token) {
		size_t len = strcspn(token, delim);
		if(!len) break;

		strncpy(tmp, token, len), tmp[len]=0;

		if(iCol==0){
			cond = ParseCondition(tmp);
			if(cond.empty()) break;
		}
		else if(iCol==1){
			bets = ParseBet(tmp);
//			if(bet<0) break;
			if(bets.empty()) break;
		}

        iCol++;
        token += len;
        if(*token) token++;
    }

    if(*token){
        err = iCol+1;
        return NULL;
    }

    TBetRow* pRow = new TBetRow;
    pRow->cond = cond;
    pRow->bets = bets;

    return pRow;
}
//---------------------------------------------------------------------------
int CompactCondition(char ch, int num)
{
 	//item&0x3=颜色 (item&7C)>>2=个数 item&0x80=是否定长
    if(!num) num = 1; //默认为1
   	int cond = (num<<2);

	if(ch=='a')
		cond += 1;
	else if(ch=='A')
		cond += 1 + 0x80;
	else if(ch=='s')
		cond += 2;
	else if(ch=='S')
		cond += 2 + 0x80;
	else if(ch=='d')
		cond += 3;
	else if(ch=='D')
        cond += 3 + 0x80;

    return cond;
}
//---------------------------------------------------------------------------
vector<int> TBetPolicy::ParseCondition(char* data)
{
    vector<int> cond;
    int len = strlen(data);
    int pos = 0;

    bool bErr = false;
    char ch = 0;
    int num = 0;
    while(pos<len){
        if(!ch){
			if(data[pos]=='a' || data[pos]=='A' || data[pos]=='s' || data[pos]=='S'
					|| road==0 && (data[pos]=='d' || data[pos]=='D'))
				ch = data[pos];
			else
				break;
		}
		else{
			if(data[pos]>='0' && data[pos]<='9')
				num = num * 10 + (data[pos]-'0');
			else if(data[pos]==ch || data[pos]==(islower(ch) ? toupper(ch) : tolower(ch))) //不能连续出现相同
				break;
			else if(data[pos]=='a' || data[pos]=='A' || data[pos]=='s' || data[pos]=='S'
					|| road==0 && (data[pos]=='d' || data[pos]=='D')){
                cond.push_back(CompactCondition(ch, num));
                ch = data[pos];
                num = 0;
            }
            else
            	break;
        }

        pos++;
    }

    if(pos<len)
        cond.clear();
    else if(ch>0)
        cond.push_back(CompactCondition(ch, num));

    return cond;
}
//---------------------------------------------------------------------------
vector<char> TBetPolicy::ParseBet(char* data)
{
	vector<char> bets;

	int len = strlen(data);
	for(int i=0; i<len; i++){
		char bet = -1;
		if(data[i]=='x') bet = 0;  		//不下注
		else if(data[i]=='a') bet = 1;  //庄/红
		else if(data[i]=='s') bet = 2;  //闲/蓝
		else if(data[i]=='d') bet = 3;  //和
		else if(data[i]=='z') bet = 4;  //本局结束

		if(bet<0){
			bets.clear();
			break;
		}
		else
            bets.push_back(bet);
	}

	return bets;
}
//---------------------------------------------------------------------------
TBetPolicy& TBetPolicy::operator = (const TBetPolicy& b)
{
	if (this != &b) {
        Reset();

        name = b.name;
		type = b.type;
		kind = b.kind;
		id = b.id;
		actived = b.actived;

		if(kind==KIND_BET_NOR){
			road = b.road;

			for(int i=0; i<b.aRows.size(); i++){
				TBetRow* ra = new TBetRow;
				TBetRow* rb = (TBetRow*)b.aRows[i];
				ra->cond = rb->cond;
				ra->bets = rb->bets;
				aRows.push_back(ra);
			}
		}
    }

    return *this;
}
//---------------------------------------------------------------------------
bool TBetPolicy::operator == (const TBetPolicy& b)
{
	if(id!=b.id || kind!=b.kind || road!=b.road || aRows.size()!=b.aRows.size())
        return false;

    for(int i=0; i<aRows.size(); i++){
       TBetRow* ra = (TBetRow*)aRows[i];
       TBetRow* rb = (TBetRow*)b.aRows[i];
		if(ra->cond != rb->cond || ra->bets != rb->bets)  //cond/bets为基本类型的vector，可直接比较
            return false;
    }

    return true;
}
//---------------------------------------------------------------------------
void TBetPolicy::AddNewRow()
{
    TBetRow* row = new TBetRow;
    aRows.push_back(row);
}
/////////////////////////////////////////////////////////////////////////////
//全局变量
vector<TBasePolicy*> g_aBetPolicies;
vector<TBasePolicy*> g_aChipPolicies;
int g_iBetPolicy = -1;  //全局打法
int g_iChipPolicy = -1;//全局注码
int g_nChipMul = 1; //全局注码倍数
TRandomChip g_RandomChip; //随机注码
TBPAskBet g_BPAskBet; //庄闲问路
TBPDiffBet g_BPDiffBet; //庄闲差

/////////////////////////////////////////////////////////////////////////////
//内部变量
vector<TBasePolicy*> u_aDelPolicies;
vector<int> u_aUserBPLen;
vector<int> u_aUserCPLen;

/////////////////////////////////////////////////////////////////////////////
//文件定义
#define USER_BPF_VERSION			0x03
#define USER_BPF_FILE				"betpolicy.dat"
#define USER_CPF_VERSION			0x07
#define USER_CPF_FILE				"chipolicy.dat"

//BetPolicy文件头
typedef struct tBPFHeader{
	char head[4];

	tBPFHeader(){
		head[0] = 'B';
		head[1] = 'P';
		head[2] = 'F';
		head[3] = USER_BPF_VERSION;
	}
} TBPFHEADER;
//ChipPolicy文件头
typedef struct tCPFHeader{
	char head[4];

	tCPFHeader(){
		head[0] = 'C';
		head[1] = 'P';
		head[2] = 'F';
		head[3] = USER_CPF_VERSION;
	}
} TCPFHEADER;

/////////////////////////////////////////////////////////////////////////////
//例程函数
int __fastcall MinChipOfPolicy(int index)
{
	TChipPolicy* pPolicy = (TChipPolicy*)g_aChipPolicies[index];
	if(pPolicy->kind==KIND_CHIP_RAN)
		return g_RandomChip.minChip;

	int minChip = -1;
	for(int i=0; i<pPolicy->aRows.size(); i++){
		TChipRow* pRow = (TChipRow*)pPolicy->aRows[i];
		if(pRow->chip>0 && (minChip<0 || pRow->chip < minChip))
			minChip = pRow->chip;
	}

    return minChip;
}
//---------------------------------------------------------------------------
int __fastcall FindPolicy(int type, int id)
{
	vector<TBasePolicy*>& aPolicies = type==TYPE_P_BET ? g_aBetPolicies : g_aChipPolicies;
	int middle, front=0, rear=aPolicies.size()-1;
	int index = -1;

	while( front<=rear ){
		if( aPolicies[front]->id==id ){
			index = front;
			break;
		}
		if( aPolicies[rear]->id==id ){
			index = rear;
			break;
		}

		middle = (front+rear)/2;
		if( aPolicies[middle]->id==id ){
			index = middle;
			break;
		}
		else if( aPolicies[middle]->id < id )
			front=middle+1;
		else
			rear=middle-1;
	}

    return index;
}
//---------------------------------------------------------------------------
void __fastcall CheckComboRow(TComboRow* row)
{
	if(row->iPolicy>=0 && row->iPolicy<g_aChipPolicies.size()
				&& g_aChipPolicies[row->iPolicy]->id==row->id)
		return;

	row->iPolicy = FindPolicy(TYPE_P_CHIP, row->id);
}
//---------------------------------------------------------------------------
vector<int> __fastcall PolicyInCombo(int id)
{
	vector<int> coms;
	for(int i=SYSCPNUM; i<g_aChipPolicies.size(); i++){
		TBasePolicy* pPolicy = g_aChipPolicies[i];
		if(pPolicy->kind==KIND_CHIP_COM){ //根据id查找iPolicy
			for(int j=0; j<pPolicy->aRows.size(); j++){
				TComboRow* row = (TComboRow*)pPolicy->aRows[j];
				if(row->id==id){
					coms.push_back(i);
					break;
				}
			}
		}
	}

	return coms;
}
//---------------------------------------------------------------------------
int __fastcall SaveBetPolicy(TBetPolicy* pPolicy, FILE* fp)
{
    int posStart = ftell(fp);

    char buff[1024];
	sprintf( buff, "%s", ((AnsiString)pPolicy->name).c_str() );
    int len = strlen(buff)+1;
    fwrite( &len, sizeof(int), 1, fp );
    fwrite( buff, sizeof(char), len, fp );

	fwrite( &pPolicy->type, sizeof(int), 1, fp );
	fwrite( &pPolicy->id, sizeof(int), 1, fp );
	fwrite( &pPolicy->kind, sizeof(int), 1, fp );
	fwrite( &pPolicy->road, sizeof(int), 1, fp );

	int num = pPolicy->aRows.size();
	fwrite( &num, sizeof(int), 1, fp );

	for(int i=0; i<num; i++){
		TBetRow* row = (TBetRow*)pPolicy->aRows[i];

		int count = row->bets.size();
		fwrite(&count, sizeof(int), 1, fp);
		for(int j=0; j<count; j++){
			fwrite(&row->bets[j], sizeof(char), 1, fp);
		}

		count = row->cond.size();
		fwrite(&count, sizeof(int), 1, fp);
		for(int j=0; j<count; j++){
			fwrite(&row->cond[j], sizeof(int), 1, fp);
		}
	}

	int posEnd = ftell( fp );

	return posEnd - posStart;
}
//---------------------------------------------------------------------------
int __fastcall SaveChipPolicy(TChipPolicy* pPolicy, FILE* fp)
{
	int posStart = ftell(fp);

	char buff[1024];
	sprintf( buff, "%s", ((AnsiString)pPolicy->name).c_str() );
	int len = strlen(buff)+1;
	fwrite( &len, sizeof(int), 1, fp );
	fwrite( buff, sizeof(char), len, fp );

	fwrite( &pPolicy->type, sizeof(int), 1, fp );
	fwrite( &pPolicy->id, sizeof(int), 1, fp );
	fwrite( &pPolicy->kind, sizeof(int), 1, fp );

	int op = (pPolicy->deadPause<<16) | pPolicy->dead;
	fwrite( &op, sizeof(int), 1, fp );
	if(pPolicy->kind==KIND_CHIP_HAN){
		op = (((TTierPolicy*)pPolicy)->bTierWinRet);
		op |= ((TTierPolicy*)pPolicy)->bTierAccChip << 1;
		op |= ((TTierPolicy*)pPolicy)->bTierLos0 << 2;
		fwrite( &op, sizeof(int), 1, fp );
	}
	else if(pPolicy->kind>=KIND_CHIP_LEV){
		op = ((TLevelPolicy*)pPolicy)->bTotalDiff;
		op |= ((TLevelPolicy*)pPolicy)->bInstant << 1;

		if(pPolicy->kind==KIND_CHIP_WLD)
			op |= ((TWLDiffPolicy*)pPolicy)->bIndie << 16;

		fwrite( &op, sizeof(int), 1, fp );
	}

	int num = pPolicy->aRows.size();
	fwrite( &num, sizeof(int), 1, fp );

	for(int i=0; i<num; i++){
		TChipRow* row = (TChipRow*)pPolicy->aRows[i];
		fwrite(&row->chip, sizeof(int), 1, fp);
		fwrite(&row->iWin, sizeof(int), 1, fp);
		fwrite(&row->iLos, sizeof(int), 1, fp);

		if(pPolicy->kind==KIND_CHIP_HAN){
			fwrite(&((TTierRow*)row)->hands, sizeof(int), 1, fp);
        }
		else if(pPolicy->kind>=KIND_CHIP_LEV){
			if(pPolicy->kind==KIND_CHIP_COM)
				fwrite(&((TComboRow*)row)->id, sizeof(int), 1, fp);

			fwrite(&((TLevelRow*)row)->nCondWin, sizeof(int), 1, fp);
			fwrite(&((TLevelRow*)row)->nCondLos, sizeof(int), 1, fp);
        }
	}

    int posEnd = ftell( fp );

    return posEnd - posStart;
}
//---------------------------------------------------------------------------
int __fastcall SavePolicy(int type, TBasePolicy* pPolicy, int index)
{
	int sysNum = type==TYPE_P_BET ? SYSBPNUM : SYSCPNUM;
    int uInd = index - sysNum;

	char szFile[256];
	sprintf( szFile, "%suser\\%s", g_AppPath, type==TYPE_P_BET ? USER_BPF_FILE : USER_CPF_FILE );
	FILE* fp = fopen( szFile, "r+b" );

	if(!fp)
		fp = fopen( szFile, "w+b");

	if(!fp)
        return -1;

    fseek( fp, 0, SEEK_END );
    int pos = ftell( fp );

    if( pos==0 ){
		if(type==TYPE_P_BET){
			TBPFHEADER header;
			fwrite( (void*)&header, sizeof(header), 1, fp );
		}
		else{
			TCPFHEADER header;
			fwrite( (void*)&header, sizeof(header), 1, fp );
		}
	}

	int posSize = type==TYPE_P_BET ? sizeof(TBPFHEADER) : sizeof(TCPFHEADER) ;
	pos = posSize + sizeof(int); //保留个数位置

	vector<int>& aLen = type==TYPE_P_BET ? u_aUserBPLen : u_aUserCPLen;
	if(uInd>0){ //寻找位置
		for(int i=0; i<uInd; i++)
			pos += aLen[i];
	}
	else if(index<0){ //寻找最后的位置，避免文件长度大于数据长度
		for(int i=0; i<aLen.size(); i++)
			pos += aLen[i];

		//分配新方案id
		pPolicy->id = type==TYPE_P_BET ? ++u_iUserBetId : ++u_iUserChipId;
    }

    fseek( fp, pos, SEEK_SET );

    int len = type==TYPE_P_BET ? SaveBetPolicy((TBetPolicy*)pPolicy, fp)
                    : SaveChipPolicy((TChipPolicy*)pPolicy, fp);

    vector<TBasePolicy*>& aPolicies = type==TYPE_P_BET ? g_aBetPolicies : g_aChipPolicies;
    if(uInd>=0){
        aLen[uInd] = len;
        u_aDelPolicies.push_back(aPolicies[index]);
        aPolicies[index] = pPolicy;

        for(int i=index+1, j=uInd+1; i<aPolicies.size(); i++, j++){
            len = type==TYPE_P_BET ? SaveBetPolicy((TBetPolicy*)aPolicies[i], fp)
                    : SaveChipPolicy((TChipPolicy*)aPolicies[i], fp);
            aLen[j] = len;
        }
    }
    else{
        aLen.push_back(len);
        aPolicies.push_back(pPolicy);
	}

    fseek(fp, posSize, SEEK_SET);
    len = aPolicies.size() - sysNum;
    fwrite(&len, sizeof(int), 1, fp);

    fclose(fp);

    return 0;
}
//---------------------------------------------------------------------------
void __fastcall RenewPolicies(int type){

	char szFile[256];
	sprintf( szFile, "%suser\\%s", g_AppPath, type==TYPE_P_BET ? USER_BPF_FILE : USER_CPF_FILE );
	FILE* fp = fopen( szFile, "r+b" );
	if(!fp)
		return;

	fseek( fp, 0, SEEK_SET );
	if(type==TYPE_P_BET){
		TBPFHEADER header;
		fwrite( (void*)&header, sizeof(header), 1, fp );
	}
	else{
		TCPFHEADER header;
		fwrite( (void*)&header, sizeof(header), 1, fp );
	}

	vector<TBasePolicy*>& aPolicies = type==TYPE_P_BET ? g_aBetPolicies : g_aChipPolicies;
	int sysNum = type==TYPE_P_BET ? SYSBPNUM : SYSCPNUM;
	int len = aPolicies.size() - sysNum;

	fwrite(&len, sizeof(int), 1, fp);

	vector<int>& aLen = type==TYPE_P_BET ? u_aUserBPLen : u_aUserCPLen;
	for(int i=sysNum, j=0; i<aPolicies.size(); i++, j++){
		int len = type==TYPE_P_BET ? SaveBetPolicy((TBetPolicy*)aPolicies[i], fp)
				: SaveChipPolicy((TChipPolicy*)aPolicies[i], fp);
		aLen[j] = len;
	}

	fclose(fp);
}
//---------------------------------------------------------------------------
int __fastcall DeletePolicy(int type, int index)
{
	int sysNum = type==TYPE_P_BET ? SYSBPNUM : SYSCPNUM;
    int uInd = index - sysNum;

    if(uInd<0)
        return -2;

	char szFile[256];
	sprintf( szFile, "%suser\\%s", g_AppPath, type==TYPE_P_BET ? USER_BPF_FILE : USER_CPF_FILE );
	FILE* fp = fopen( szFile, "r+b" );

    if(!fp)
        return -1;

    int posSize = type==TYPE_P_BET ? sizeof(TBPFHEADER) : sizeof(TCPFHEADER) ;
    int pos = posSize + sizeof(int); //保留个数位置

    vector<int>& aLen = type==TYPE_P_BET ? u_aUserBPLen : u_aUserCPLen;
    for(int i=0; i<uInd; i++){//寻找位置
        pos += aLen[i];
    }

    fseek( fp, pos, SEEK_SET );

    vector<TBasePolicy*>& aPolicies = type==TYPE_P_BET ? g_aBetPolicies : g_aChipPolicies;

    aLen.erase(aLen.begin()+uInd);
	u_aDelPolicies.push_back(aPolicies[index]);
	aPolicies.erase(aPolicies.begin()+index);

	int len = 0;
	for(int i=index, j=uInd; i<aPolicies.size(); i++, j++){ //后面的策略前移
		len = type==TYPE_P_BET ? SaveBetPolicy((TBetPolicy*)aPolicies[i], fp)
				: SaveChipPolicy((TChipPolicy*)aPolicies[i], fp);
			aLen[j] = len;
	}

	fseek(fp, posSize, SEEK_SET);
	len = aPolicies.size() - sysNum;
	fwrite(&len, sizeof(int), 1, fp);

	fclose(fp);

//	if(type==TYPE_P_CHIP && u_aDelPolicies.back()->kind==KIND_CHIP_NOR){
//		//处理组合序号
//		for(int i=SYSCPNUM; i<g_aChipPolicies.size(); i++){
//			TBasePolicy* pPolicy = g_aChipPolicies[i];
//			if(pPolicy->kind==KIND_CHIP_COM){ //根据id查找iPolicy
//				for(int j=0; j<pPolicy->aRows.size(); j++){
//					TComboRow* row = (TComboRow*)pPolicy->aRows[j];
//					if(row->iPolicy > index)
//						row->iPolicy--;
//				}
//			}
//		}
//	}

    return 0;
}
//---------------------------------------------------------------------------
void __fastcall LoadSystemBetPolicies()
{
	char tmp[1024];
	for(int i=0; i<SYSBPNUM; i++){
		TBetPolicy* pPolicy = new TBetPolicy;
		pPolicy->id = i;

		int iPart = 0;
		const char* delim = "\n";
		char *token = sysBet[i];
		while(*token) {
			size_t len = strcspn(token, delim);
			if(!len) break;

			strncpy(tmp, token, len), tmp[len]=0;

			if(iPart==0){
				pPolicy->name = "内置" + String(tmp);
			}
			else if(iPart==1){
				int kind, road;
				sscanf(tmp, "%2X%1X", &kind, &road);

				pPolicy->id = i+1;
                pPolicy->kind = kind;
				pPolicy->road = road;
				pPolicy->actived = true;
			}
			else if(iPart==2){
				int err = pPolicy->ParsePolicy(tmp, TYPE_P_BET);
				if(err) break;
			}

			iPart++;
			token += len;
			if(*token) token++;
		}

		if(*token){
			delete pPolicy;
		 }
		else{
			pPolicy->type = 0;
			g_aBetPolicies.push_back(pPolicy);
		}
	}
}
//---------------------------------------------------------------------------
void __fastcall LoadUserBetPolicies()
{
	char szFile[256];
	sprintf( szFile, "%suser\\%s", g_AppPath, USER_BPF_FILE );
	FILE* fp = fopen( szFile, "rb" );

	if(!fp)
		return;

	char buf[1024];
	char head[8];
	TBPFHEADER header;
	int ret = fread( (void*)head, 1, sizeof(header), fp );

	if( ret==sizeof(header) && !memcmp(head, &header, 3) ){
		int size;
		fread(&size, sizeof(int), 1, fp);

		for(int i=0; i<size; i++){
            int posStart = ftell(fp);
            TBetPolicy* pPolicy = new TBetPolicy;

            int num;
            fread(&num, sizeof(int), 1, fp);
            fread(buf, sizeof(char), num, fp);
			pPolicy->name = buf;
			pPolicy->actived = true;

			fread(&pPolicy->type, sizeof(int), 1, fp);

			if(head[3]>=3){
				int id;
				fread(&id, sizeof(int), 1, fp);
				pPolicy->id = id;

				if(id>u_iUserBetId)
					u_iUserBetId = id;
			}
			else{
				pPolicy->id = ++u_iUserBetId;
			}

			if(head[3]>0)
				fread(&pPolicy->kind, sizeof(int), 1, fp);
			fread(&pPolicy->road, sizeof(int), 1, fp);

            fread(&num, sizeof(int), 1, fp);
			for(int k=0; k<num; k++){
				TBetRow* row = new TBetRow;
				int count;

				if(head[3]<2){
					int bet;
					fread(&bet, sizeof(int), 1, fp);
					row->bets.push_back((char)bet);
				}
				else{
					fread(&count, sizeof(int), 1, fp);
					for(int j=0; j<count; j++){
						char bet;
						fread(&bet, sizeof(char), 1, fp);
						row->bets.push_back(bet);
					}
				}

				fread(&count, sizeof(int), 1, fp);
				for(int j=0; j<count; j++){
					int cond;
					fread(&cond, sizeof(int), 1, fp);
					row->cond.push_back(cond);
				}
                pPolicy->aRows.push_back(row);
            }

            int posEnd = ftell(fp);
            g_aBetPolicies.push_back(pPolicy);
            u_aUserBPLen.push_back(posEnd-posStart);
        }
    }

	fclose(fp);

	if(head[3]!=USER_BPF_VERSION)
		RenewPolicies(TYPE_P_BET);
}
//---------------------------------------------------------------------------
void __fastcall LoadSystemChipPolicies()
{
    char tmp[1024];
    for(int i=0; i<SYSCPNUM; i++){
		TChipPolicy* pPolicy = NULL;

		int iPart = 0;
		char name[64] = "内置";
		const char* delim = "\n";
		char *token = sysChip[i];
		while(*token) {
			size_t len = strcspn(token, delim);
			if(!len) break;

			strncpy(tmp, token, len), tmp[len]=0;

			if(iPart==0)
				strcat(name, tmp);
			else if(iPart==1){ //kkpdo
				int kind;
				sscanf(tmp, "%2X", &kind);

				if(kind==KIND_CHIP_HAN)
					pPolicy = new TTierPolicy;
				else if(kind==KIND_CHIP_LEV || kind==KIND_CHIP_COM)
					pPolicy = new TLevelPolicy;
				else if(kind==KIND_CHIP_WLD)
					pPolicy = new TWLDiffPolicy;
				else
					pPolicy = new TChipPolicy;

                pPolicy->id = i+1;
				pPolicy->name = name;
				pPolicy->kind = kind;
				pPolicy->actived = true;

				if(kind<KIND_CHIP_RAN){
					int dead, pause;
					sscanf(tmp+2, "%1X%1X", &pause, &dead);
					pPolicy->dead = dead;
					pPolicy->deadPause = pause;

					if(kind==KIND_CHIP_HAN){
						int op;
						sscanf(tmp+4, "%1X", &op);
						((TTierPolicy*)pPolicy)->bTierWinRet = op & 0x1;
						((TTierPolicy*)pPolicy)->bTierAccChip = op & 0x2;
					}
					else if(kind>=KIND_CHIP_LEV){
						int op;
						sscanf(tmp+4, "%1X", &op);
						((TLevelPolicy*)pPolicy)->bTotalDiff = op & 0x1;
						((TLevelPolicy*)pPolicy)->bInstant = op & 0x2;

						if(kind==KIND_CHIP_WLD)
							((TWLDiffPolicy*)pPolicy)->bIndie = op & 0x4;
					}
				}
			}
            else if(iPart==2){
                int err = pPolicy->ParsePolicy(tmp, TYPE_P_CHIP);
                if(err) break;
            }

            iPart++;
            token += len;
            if(*token) token++;
        }

        if(*token){
            delete pPolicy;
        }
        else{
            pPolicy->type = 0;
			g_aChipPolicies.push_back(pPolicy);

//			if(pPolicy->kind==KIND_CHIP_COM){ //根据id查找iPolicy
//				for(int j=0; j<pPolicy->aRows.size(); j++){
//					TComboRow* pRow = (TComboRow*)pPolicy->aRows[j];
//					for(int k=0; k<g_aChipPolicies.size(); k++){
//						if(g_aChipPolicies[k]->id == pRow->id){
//							pRow->iPolicy = k;
//							break;
//						}
//					}
//				}
//			}
        }
    }
}
//---------------------------------------------------------------------------
void __fastcall LoadUserChipPolicies()
{
	char szFile[256];
	sprintf( szFile, "%suser\\%s", g_AppPath, USER_CPF_FILE );
	FILE* fp = fopen( szFile, "rb" );

    if(!fp)
        return;

    char buf[1024];
    char head[8];
	TCPFHEADER header;
	int ret = fread( (void*)head, 1, sizeof(header), fp );

	if( ret==sizeof(header) && !memcmp(head, &header, 3) && head[3]>1 ){
        int size;
        fread(&size, sizeof(int), 1, fp);

		int num;
		int type;
		int id;
		char name[64];
		for(int i=0; i<size; i++){
			int posStart = ftell(fp);
			TChipPolicy* pPolicy = NULL;

			fread(&num, sizeof(int), 1, fp);
			fread(name, sizeof(char), num, fp);

			fread(&type, sizeof(int), 1, fp);

			if(head[3]>=5){
				fread(&id, sizeof(int), 1, fp);
				if(id>u_iUserChipId)
					u_iUserChipId = id;
			}
			else{
				id = ++u_iUserChipId;
			}

			int kind = 0;
			if(head[3]>=4){
				fread(&kind, sizeof(int), 1, fp);
				if(kind==KIND_CHIP_HAN)
					pPolicy = new TTierPolicy;
				else if(kind==KIND_CHIP_LEV || kind==KIND_CHIP_COM)
					pPolicy = new TLevelPolicy;
				else if(kind==KIND_CHIP_WLD)
					pPolicy = new TWLDiffPolicy;
				else
					pPolicy = new TChipPolicy;

				int op = (pPolicy->deadPause<<16) | pPolicy->dead;
				fread( &op, sizeof(int), 1, fp );
				pPolicy->dead = op & 0xFF;
				pPolicy->deadPause = (op & 0xFF0000)>>16;

				if(kind==KIND_CHIP_HAN){
					fread( &op, sizeof(int), 1, fp );
					((TTierPolicy*)pPolicy)->bTierWinRet = op & 0x1; // op & 0xFF;
					if(head[3]>6){
						((TTierPolicy*)pPolicy)->bTierAccChip = op & 0x2;
						((TTierPolicy*)pPolicy)->bTierLos0 = op & 0x4;
					}
					else{
						((TTierPolicy*)pPolicy)->bTierAccChip = op & 0x10000; // (op & 0xFF0000)>>16;
					}
				}
				else if((kind>=KIND_CHIP_LEV && kind<=KIND_CHIP_WLD) && head[3]>=6){
					fread( &op, sizeof(int), 1, fp );
					((TLevelPolicy*)pPolicy)->bTotalDiff = op & 0x1;
					((TLevelPolicy*)pPolicy)->bInstant = op & 0x2;

					if(kind==KIND_CHIP_WLD)
						((TWLDiffPolicy*)pPolicy)->bIndie = op & 0x10000;
				}
			}
			else if(head[3]>=1){
				fread(&num, sizeof(int), 1, fp);
				char dead = num & 0x0F,
					pause = (num & 0xF0)>>4,
					kind = head[3]<3 ? (num & 0x100)>>8 : (num & 0xFF00)>>8;

				if(kind==KIND_CHIP_HAN){
					pPolicy = new TTierPolicy;
					((TTierPolicy*)pPolicy)->bTierWinRet =  head[3]<3 ? (num & 0x200)>>9 : (num & 0x10000)>>16;
					((TTierPolicy*)pPolicy)->bTierAccChip = head[3]<3 ? (num & 0x400)>>10 : (num & 0x20000)>>17;
				}
				else{
					pPolicy = new TChipPolicy;
				}

				pPolicy->dead = dead;
				pPolicy->deadPause = pause;
			}
			else{
				pPolicy = new TChipPolicy;
			}

			pPolicy->type = type;
			pPolicy->kind = kind;
			pPolicy->name = name;
			pPolicy->id = id;
			pPolicy->actived = true;

			fread(&num, sizeof(int), 1, fp);
			for(int j=0; j<num; j++){
				TChipRow* row = kind==KIND_CHIP_HAN ? new TTierRow
								: kind==KIND_CHIP_LEV || kind==KIND_CHIP_WLD ? new TLevelRow
								: kind==KIND_CHIP_COM ? new TComboRow
								: new TChipRow;

				fread(&row->chip, sizeof(int), 1, fp);
				fread(&row->iWin, sizeof(int), 1, fp);
				fread(&row->iLos, sizeof(int), 1, fp);

				if(pPolicy->kind==KIND_CHIP_HAN){
					fread(&((TTierRow*)row)->hands, sizeof(int), 1, fp);
				}
				else if(pPolicy->kind>=KIND_CHIP_LEV){
					if(pPolicy->kind==KIND_CHIP_COM)
						fread(&((TComboRow*)row)->id, sizeof(int), 1, fp);

					fread(&((TLevelRow*)row)->nCondWin, sizeof(int), 1, fp);
					fread(&((TLevelRow*)row)->nCondLos, sizeof(int), 1, fp);
				}

				row->iSeq = j+1;
                pPolicy->aRows.push_back(row);
            }

            int posEnd = ftell(fp);
            g_aChipPolicies.push_back(pPolicy);
            u_aUserCPLen.push_back(posEnd-posStart);
        }
	}

	fclose(fp);

//	for(int i=SYSCPNUM; i<g_aChipPolicies.size(); i++){
//		TBasePolicy* pPolicy = g_aChipPolicies[i];
//		if(pPolicy->kind==KIND_CHIP_COM){ //根据id查找iPolicy
//			for(int j=0; j<pPolicy->aRows.size(); j++){
//				TComboRow* row = (TComboRow*)pPolicy->aRows[j];
//				for(int k=0; k<g_aChipPolicies.size(); k++){
//					if(g_aChipPolicies[k]->id == row->id){
//						row->iPolicy = k;
//						break;
//					}
//				}
//			}
//		}
//	}

	if(head[3]!=USER_CPF_VERSION)
		RenewPolicies(TYPE_P_CHIP);
}
//---------------------------------------------------------------------------
void __fastcall LoadPolicies()
{
    LoadSystemBetPolicies();
    LoadUserBetPolicies();
    LoadSystemChipPolicies();
    LoadUserChipPolicies();
}
//---------------------------------------------------------------------------