/* 襯澀爛楮   */
#include "version.h"
#include <stdio.h>
#include <string.h>
#include "common.h"
#include "util.h"
#include "buf.h"
#include "char_base.h"
#include "char.h"
#include "configfile.h"
#include "encount.h"
#include "enemy.h"
#include "pet.h"
#include "enemyexptbl.h"
#include "petmail.h"
#include "battle.h"
#include "pet_skillinfo.h"
#include "anim_tbl.h"
#include "log.h"

#ifdef _ADD_ENCOUNT           // WON ADD 增加敵遭遇觸發修件
#include "encount.h"
#include "npcutil.h"
#endif

#define		ENEMY_INDEXTABLEMAXSIZE		16
static ENEMY_EnemyTable *ENEMY_enemy;
static int              ENEMY_enemynum;

static ENEMYTEMP_Table *ENEMYTEMP_enemy;
static int              ENEMYTEMP_enemynum;

static GROUP_Table 		*GROUP_group;
static int              GROUP_groupnum;

int                     ENEMY_indextable[ENEMY_INDEXTABLEMAXSIZE];

#ifdef _ENEMY_FALLGROUND
extern	tagRidePetTable ridePetTable[296];
#endif

INLINE BOOL ENEMY_CHECKINDEX( int index)
{
    if( index < 0 || index >= ENEMY_enemynum) return FALSE;
    return TRUE;
}

static INLINE BOOL ENEMY_CHECKINTDATAINDEX( int index)
{
    if( index< 0 || index >= ENEMY_DATAINTNUM) return FALSE;
    return TRUE;
}

static INLINE BOOL ENEMY_CHECKCHARDATAINDEX( int index)
{
    if( index< 0 || index >= ENEMY_DATACHARNUM) return FALSE;
    return TRUE;
}

INLINE int ENEMY_getInt( int index, ENEMY_DATAINT element)
{
    return ENEMY_enemy[index].intdata[element];
}

INLINE int *ENEMY_getIntdata( int index)
{
	return ENEMY_enemy[index].intdata;
}

INLINE int ENEMY_setInt( int index, ENEMY_DATAINT element, int data)
{
    int buf;
    buf = ENEMY_enemy[index].intdata[element];
    ENEMY_enemy[index].intdata[element] = data;
    return buf;
}

INLINE char *ENEMY_getChar( int index, ENEMY_DATACHAR element)
{
    if(!ENEMY_CHECKINDEX(index))return NULL;
    if(!ENEMY_CHECKCHARDATAINDEX(element))return NULL;

    return ENEMY_enemy[index].chardata[element].string;
}

INLINE BOOL ENEMY_setChar( int index ,ENEMY_DATACHAR element, char* new )
{
    if(!ENEMY_CHECKINDEX(index))return FALSE;
    if(!ENEMY_CHECKCHARDATAINDEX(element))return FALSE;
    strcpysafe( ENEMY_enemy[index].chardata[element].string,
                sizeof(ENEMY_enemy[index].chardata[element].string),
                new );
    return TRUE;
}

int ENEMY_getEnemyNum( void)
{
    return ENEMY_enemynum;
}

INLINE BOOL ENEMYTEMP_CHECKINDEX( int index)
{
    if( index < 0 || index >= ENEMYTEMP_enemynum) return FALSE;
    return TRUE;
}

static INLINE BOOL ENEMYTEMP_CHECKINTDATAINDEX( int index)
{
    if( index< 0 || index >= E_T_DATAINTNUM) return FALSE;
    return TRUE;
}

static INLINE BOOL ENEMYTEMP_CHECKCHARDATAINDEX( int index)
{
    if( index< 0 || index >= E_T_DATACHARNUM) return FALSE;
    return TRUE;
}

INLINE int ENEMYTEMP_getInt( int index, ENEMYTEMP_DATAINT element)
{
    return ENEMYTEMP_enemy[index].intdata[element];
}

INLINE int ENEMYTEMP_setInt( int index, ENEMYTEMP_DATAINT element, int data)
{
    int buf;
    buf = ENEMYTEMP_enemy[index].intdata[element];
    ENEMYTEMP_enemy[index].intdata[element] = data;
    return buf;
}

INLINE char *ENEMYTEMP_getChar( int index, ENEMYTEMP_DATACHAR element)
{
    if(!ENEMYTEMP_CHECKINDEX(index))return NULL;
    if(!ENEMYTEMP_CHECKCHARDATAINDEX(element))return NULL;

    return ENEMYTEMP_enemy[index].chardata[element].string;
}

INLINE BOOL ENEMYTEMP_setChar( int index ,ENEMYTEMP_DATACHAR element, char* new )
{
    if(!ENEMYTEMP_CHECKINDEX(index))return FALSE;
    if(!ENEMYTEMP_CHECKCHARDATAINDEX(element))return FALSE;
    strcpysafe( ENEMYTEMP_enemy[index].chardata[element].string,
                sizeof(ENEMYTEMP_enemy[index].chardata[element].string),
                new );
    return TRUE;
}

int ENEMYTEMP_getEnemyNum( void)
{
    return ENEMYTEMP_enemynum;
}

INLINE BOOL GROUP_CHECKINDEX( int index)
{
    if( index < 0 || index >= GROUP_groupnum) return FALSE;
    return TRUE;
}

static INLINE BOOL GROUP_CHECKINTDATAINDEX( int index)
{
    if( index< 0 || index >= GROUP_DATAINTNUM) return FALSE;
    return TRUE;
}

static INLINE BOOL GROUP_CHECKCHARDATAINDEX( int index)
{
    if( index< 0 || index >= GROUP_DATACHARNUM) return FALSE;
    return TRUE;
}

INLINE int GROUP_getInt( int index, GROUP_DATAINT element)
{
    return GROUP_group[index].intdata[element];
}

INLINE int GROUP_setInt( int index, GROUP_DATAINT element, int data)
{
    int buf;
    buf = GROUP_group[index].intdata[element];
    GROUP_group[index].intdata[element] = data;
    return buf;
}

INLINE char *GROUP_getChar( int index, GROUP_DATACHAR element)
{
    if(!GROUP_CHECKINDEX(index))return NULL;
    if(!GROUP_CHECKCHARDATAINDEX(element))return NULL;

    return GROUP_group[index].chardata[element].string;
}

INLINE BOOL GROUP_setChar( int index ,GROUP_DATACHAR element, char* new )
{
    if(!GROUP_CHECKINDEX(index))return FALSE;
    if(!GROUP_CHECKCHARDATAINDEX(element))return FALSE;
    strcpysafe( GROUP_group[index].chardata[element].string,
                sizeof(GROUP_group[index].chardata[element].string),
                new );
    return TRUE;
}

int GROUP_getEnemyNum( void)
{
    return GROUP_groupnum;
}

BOOL ENEMYTEMP_initEnemy( char* filename )
{
    FILE*   f;
    char    line[256];
    int     linenum=0;
    int     enemytemp_readlen=0;
	int		i,j;

#ifdef _ENEMYTEMP_OPTIMUM
	int		max_enemytempid =0;
	char	token[256];
#endif
    f = fopen(filename,"r");
    if( f == NULL ){
        print( "文件打開失敗\n");
        return FALSE;
    }

    ENEMYTEMP_enemynum=0;

    /*  引內  躲卅墊互窒墊丐月井升丹井譬屯月    */
    while( fgets( line, sizeof( line ), f ) ){
        linenum ++;
        if( line[0] == '#' )continue;        /* comment */
        if( line[0] == '\n' )continue;       /* none    */
        chomp( line );

#ifdef _ENEMYTEMP_OPTIMUM // Robin 取出最大ENEMYTEMP ID
		if( getStringFromIndexWithDelim( line, ",", E_T_DATACHARNUM+E_T_TEMPNO+1,
				token, sizeof(token)) == FALSE )
			continue;
		max_enemytempid = max( atoi( token), max_enemytempid);
#endif

        ENEMYTEMP_enemynum++;
    }

    if( fseek( f, 0, SEEK_SET ) == -1 ){
        fprint( "Seek Error\n" );
        fclose(f);
        return FALSE;
    }

#ifdef _ENEMYTEMP_OPTIMUM
	print("\n 有效EBT:%d 最大EBT:%d \n", ENEMYTEMP_enemynum, max_enemytempid);
	ENEMYTEMP_enemynum = max_enemytempid +1;
#endif

    ENEMYTEMP_enemy = allocateMemory( sizeof(struct tagENEMYTEMP_Table)
                                   * ENEMYTEMP_enemynum );
    if( ENEMYTEMP_enemy == NULL ){
        fprint( "無法分配內存 %d\n" ,
                sizeof(struct tagENEMYTEMP_Table)*ENEMYTEMP_enemynum);
        fclose( f );
        return FALSE;
    }

	/* 賡渝祭 */
    for( i = 0; i < ENEMYTEMP_enemynum; i ++ ) {
    	for( j = 0; j < E_T_DATAINTNUM; j ++ ) {
    		ENEMYTEMP_setInt( i,j,-1);
    	}
    }
    linenum = 0;
    while( fgets( line, sizeof( line ), f ) ){
        linenum ++;
        if( line[0] == '#' )continue;        /* comment */
        if( line[0] == '\n' )continue;       /* none    */
        chomp( line );
        replaceString( line, '\t' , ' ' );
{
        char    buf[256];
        for( i = 0; i < strlen( line); i ++) {
            if( line[i] != ' ' ) {
                break;
            }
            strcpy( buf, &line[i]);
        }
        if( i != 0 ) {
            strcpy( line, buf);
        }
}
{
        char    token[256];
        int     ret;

#ifdef _ENEMYTEMP_OPTIMUM
		if( getStringFromIndexWithDelim( line, ",", E_T_DATACHARNUM+E_T_TEMPNO+1,
				token, sizeof(token)) == FALSE )
			continue;
		enemytemp_readlen = atoi(token);
#endif

#if 0
        ret = getStringFromIndexWithDelim( line,",",1,token,
                                           sizeof(token));
        if( ret==FALSE ){
            fprint("文件語法錯誤:%s 第%行\n",filename,linenum);
            continue;
        }
        ENEMYTEMP_setChar( enemytemp_readlen, E_T_NAME, token);
#endif
		for( i = 0; i < E_T_DATACHARNUM; i ++ ) {
	        ret = getStringFromIndexWithDelim( line,",",i+1,token,
	                                           sizeof(token));
	        if( ret==FALSE ){
	            fprint("文件語法錯誤:%s 第%d行\n",filename,linenum);
	            continue;
	        }
	        ENEMYTEMP_setChar( enemytemp_readlen, E_T_NAME + i, token);

		}
#define	ENEMYTEMP_STARTINTNUM		(E_T_DATACHARNUM+1)
        for( i = ENEMYTEMP_STARTINTNUM; i < E_T_DATAINTNUM+ENEMYTEMP_STARTINTNUM; i ++ ) {
            ret = getStringFromIndexWithDelim( line,",",i,token,
                                               sizeof(token));
            if( ret==FALSE ){
                fprint("文件語法錯誤:%s 第%d行\n",filename,linenum);
                break;
            }
            if( strlen( token) != 0 ) {
	            ENEMYTEMP_setInt( enemytemp_readlen, i - ENEMYTEMP_STARTINTNUM, atoi( token));
			}
        }
        if( i < E_T_DATAINTNUM+ENEMYTEMP_STARTINTNUM ) continue;


        enemytemp_readlen ++;
}
    }
    fclose(f);

    ENEMYTEMP_enemynum = enemytemp_readlen;

    print( "有效寵物基本狀態數是 %d...", ENEMYTEMP_enemynum );

#if 0

    for( i=0; i <ENEMYTEMP_enemynum ; i++ ){
        for( j = 0; j < E_T_DATACHARNUM; j ++ ) {
	        print( "%s ", ENEMYTEMP_getChar( i, j));
        }
        for( j = 0; j < E_T_DATAINTNUM; j ++ ) {
            print( "%d ", ENEMYTEMP_getInt( i, j));
        }
        print( "\n");
    }
#endif
    return TRUE;
}

BOOL ENEMYTEMP_reinitEnemy( void )
{
	freeMemory( ENEMYTEMP_enemy);
	return( ENEMYTEMP_initEnemy( getEnemyBasefile()));
}

int ENEMYTEMP_getEnemyTempArray( int enemyindex)
{
	if( !ENEMY_CHECKINDEX( enemyindex)) return -1;
	return ENEMY_enemy[enemyindex].enemytemparray;
}

int ENEMYTEMP_getEnemyTempArrayFromTempNo( int EnemyTempNo)
{
#ifdef _ENEMYTEMP_OPTIMUM
	if( EnemyTempNo >= 0 && EnemyTempNo < ENEMYTEMP_enemynum )
		return	EnemyTempNo;
#else
	int		i;
	for( i = 0; i < ENEMYTEMP_enemynum; i ++ ) {
		if( ENEMYTEMP_getInt( i, E_T_TEMPNO) == EnemyTempNo) {
			return i;
		}
	}
#endif
	return -1;
}

int ENEMYTEMP_getEnemyTempArrayFromInitnum( int EnemyTempNo)
{
	int		i;
	for( i = 0; i < ENEMYTEMP_enemynum; i ++ ) {
		if( ENEMYTEMP_getInt( i, E_T_INITNUM) == EnemyTempNo) {
			return i;
		}
	}
	return -1;
}

BOOL ENEMY_initEnemy( char* filename )
{
    FILE*   f;
    char    line[256];
    int     linenum=0;
    int     enemy_readlen=0;
	int		i,j;
#ifdef _ENEMY_OPTIMUM
	int		max_enemyid =0;
	char	token[256];
#endif

    f = fopen(filename,"r");