#include "version.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "skill.h"
#include "util.h"
#include "char.h"

#ifdef _CHAR_PROFESSION			// WON ADD 人物職業(yè)
#include "battle.h"
#include "profession_skill.h"
#endif


static SKILL_intDataSetting SKILL_setint[SKILL_DATAINTNUM]={
    {"lv"},           /*  SKILL_LEVEL	*/
    {"id"},           /*  SKILL_ID		*/
};

static SKILL_charDataSetting SKILL_setchar[SKILL_DATACHARNUM]={
};




static char    SKILL_dataString[STRINGBUFSIZ];

char* SKILL_makeStringFromSkillData( Skill* sk )
{
    int     i;
    int     strlength=0;

    for( i = 0 ; i < SKILL_DATAINTNUM ; i ++ ){
        char    linedata[128];
        snprintf( linedata , sizeof(linedata),
                  "%s=%d" NONCHAR_DELIMITER,
                  SKILL_setint[i].dumpskill, sk->data[i] );

        strcpysafe( &SKILL_dataString[strlength],
                    sizeof( SKILL_dataString ) - strlength,
                    linedata );
        strlength += strlen( linedata );
        if( strlength > sizeof( SKILL_dataString ) )goto RETURN;
    }

    for( i = 0 ; i < SKILL_DATACHARNUM ; i ++ ){
        char    linedata[128];
        char    escapebuffer[128];
        snprintf( linedata, sizeof(linedata),
                  "%s=%s" NONCHAR_DELIMITER,
                  SKILL_setchar[i].dumpskill,
                  makeEscapeString(sk->string[i].string,escapebuffer,
                                   sizeof(escapebuffer)));

        strcpysafe( &SKILL_dataString[strlength],
                    sizeof( SKILL_dataString ) - strlength,
                    linedata );
        strlength += strlen( linedata );
        if( strlength > sizeof( SKILL_dataString ) )goto RETURN;
    }

RETURN:
    dchop( SKILL_dataString , NONCHAR_DELIMITER );

    return SKILL_dataString;
}


BOOL SKILL_makeSkillFromStringToArg( char* src, Skill* sk )
{
    int     readindex=1;
    while( 1 ){
        BOOL    ret;
        char    linebuf[512];
        char    first[256];
        char    second[256];
        int     i;


        ret = getStringFromIndexWithDelim( src ,NONCHAR_DELIMITER ,
                                           readindex,
                                           linebuf,  sizeof( linebuf ) );
        if( ret == FALSE )
            break;

        ret = getStringFromIndexWithDelim( linebuf ,"=", 1,
                                           first,  sizeof( first ) );
        if( ret == FALSE )  return FALSE;
        strcpysafe( second , sizeof( second ),
                    linebuf + strlen(first) + strlen("=") );

        for( i = 0 ; i < SKILL_DATAINTNUM ; i ++ ){
            if( strcmp(first ,SKILL_setint[i].dumpskill) == 0 ){
                sk->data[i] = atoi( second );
                goto NEXT;
            }
        }

        for( i = 0 ; i < SKILL_DATACHARNUM ; i ++ ){
            if( strcmp(first ,SKILL_setchar[i].dumpskill) == 0 ){
                strcpysafe( sk->string[i].string,
                            sizeof(sk->string[i].string),
                            makeStringFromEscaped(second) );
                goto NEXT;
            }
        }

        fprint( "??? : %s[%s]\n" , linebuf, first );
        
    NEXT:
        readindex++;
    }

    return TRUE;
}

#ifdef _CHAR_PROFESSION			// WON ADD 人物職業(yè)
INLINE int SKILL_getRealInt( Skill* skill, int element)
{
    return skill->data[element];
}
#endif

INLINE int SKILL_getInt( Skill* skill, int element)
{
	int value = skill->data[element];

	if( element == SKILL_LEVEL )	value /= 100;

    return value;
}


INLINE int SKILL_setInt( Skill* skill, int element, int new)
{
    int     buf = SKILL_getInt( skill, element );
    skill->data[element] = new;
    return buf;
}

#ifndef _PROFESSION_SKILL			// WON ADD 人物職業(yè)技能
static void SKILL_setitemlimit( int charaindex, Skill* sk );
static void SKILL_setmerchant( int charaindex, Skill* sk );
static void SKILL_setlevel( int charaindex, Skill* sk );
#endif

static SKILL_table  SKILL_tbl[]={

#ifdef _PROFESSION_SKILL			// WON ADD 人物職業(yè)技能
	{ 100,	NULL},		// 1
	{ 100,	NULL},
	{ 100,	NULL},
	{ 100,	NULL},
	{ 100,	NULL},
	{ 100,	NULL},
	{ 100,	NULL},
	{ 100,	NULL},
	{ 100,	NULL},
	{ 100,	NULL},
	{ 100,	NULL},
	{ 100,	NULL},
	{ 100,	NULL},
	{ 100,	NULL},
	{ 100,	NULL},
	{ 100,	NULL},		// 16
#else
    {8,SKILL_setlevel},			/*  SKILL_FIRE				*/
    {4,NULL},					/*  SKILL_MAGICIAN			*/
    {4,NULL},					/*  SKILL_PREIST			*/
    {8,SKILL_setitemlimit},		/*  SKILL_ALOTOFTHINGS		*/
    {8,NULL},					/*  SKILL_AVOIDRATEUP		*/
    {4,SKILL_setlevel},			/*  SKILL_DETERMINEITEM		*/
    {5,SKILL_setlevel},			/*  SKILL_DETERMINEOTHERS	*/
    {8,SKILL_setmerchant},		/*  SKILL_MERCHANT			*/
    {8,SKILL_setlevel},			/*  SKILL_HEALER			*/
    {8,SKILL_setlevel},			/*  SKILL_LARGEVOICE		*/
#endif
};


#ifndef _PROFESSION_SKILL			// WON ADD 人物職業(yè)技能
static void SKILL_setitemlimit( int charaindex, Skill* sk )
{
    static int itemlimit[9]={
        7 + 8 + 4*0,
        7 + 8 + 4*1,
        7 + 8 + 4*2,
        7 + 8 + 4*3,
        7 + 8 + 4*4,
        7 + 8 + 4*5,
        7 + 8 + 4*6,
        7 + 8 + 4*7,
        7 + 8 + 4*8,
    };
    int     level;
    if( !CHAR_CHECKINDEX(charaindex) )return;
    if( sk->data[SKILL_IDENTITY] != SKILL_ALOTOFTHINGS )return;
    level = sk->data[SKILL_LEVEL];
    if( level < 0 )level = 0;
    if( level>=arraysizeof(itemlimit) ) level=arraysizeof(itemlimit) - 1;
}


static void SKILL_setmerchant( int charaindex, Skill* sk )
{
    int     level;
    int     merchantlevel=0;

    if( !CHAR_CHECKINDEX(charaindex) )return;
    if( sk->data[SKILL_IDENTITY] != SKILL_MERCHANT )return;

    level = sk->data[SKILL_LEVEL];
    if( level < 0 )level = 0;
    if( level >= SKILL_tbl[sk->data[SKILL_IDENTITY]].maxlevel )
        level  = SKILL_tbl[sk->data[SKILL_IDENTITY]].maxlevel;

    SETHIGHVALUE(merchantlevel,(100 - level*5));
    SETLOWVALUE(merchantlevel,(20 + level*5));
    
    CHAR_setInt( charaindex,CHAR_MERCHANTLEVEL,merchantlevel );
}


static void SKILL_setlevel( int charaindex, Skill* sk )
{
    static struct skillvalset
    {
        SKILL_ID        id;
        CHAR_DATAINT    charadataindex;
    } skvalset[] = {
        { SKILL_DETERMINEITEM,      CHAR_DETERMINEITEM },
        { SKILL_DETERMINEOTHERS,    CHAR_RADARSTRENGTH },
        { SKILL_HEALER,             CHAR_HEALERLEVEL },
        { SKILL_LARGEVOICE,         CHAR_CHATVOLUME },
    };
    int id;
    int i;
    int index=-1;
    int level;

    if( !CHAR_CHECKINDEX(charaindex) )return;
    id = sk->data[SKILL_IDENTITY];
    for( i=0 ; i<arraysizeof(skvalset) ; i ++ )
        if( skvalset[i].id == id )
            index = i;

    if( index == -1 )return;

    level = sk->data[SKILL_LEVEL];
    if( level < 0 )level = 0;
    if( level >= SKILL_tbl[id].maxlevel )
        level  = SKILL_tbl[id].maxlevel;

    CHAR_setInt(charaindex,skvalset[index].charadataindex,level );
}
#endif





#define SKILLSTRINGBUFSIZ   256

static char    ITEM_statusStringBuffer[SKILLSTRINGBUFSIZ];


#ifdef _CHAR_PROFESSION			// WON ADD 人物職業(yè)
char* SKILL_makeSkillStatusString( Skill* skill, int charaindex, int skill_num )
{
	  int skillindex=SKILL_getInt( skill,SKILL_IDENTITY);
	  int Pskill=PROFESSION_SKILL_getskillArray( skillindex);
	  int skill_level=0, cost_mp=0;
		
	  // 人物技能等級
	  skill_level = SKILL_getInt( skill, SKILL_LEVEL);
	
	  // 耗費MP
	  if( (cost_mp = PROFESSION_MAGIC_COST_MP( charaindex, skill_num )) == -1 )
		cost_mp = PROFESSION_SKILL_getInt( Pskill, PROFESSION_SKILL_COST_MP);

	  snprintf( ITEM_statusStringBuffer, sizeof( ITEM_statusStringBuffer ),
			"%d|%d|%d|%d|%d|%d|%d|%s|%s",
			PROFESSION_SKILL_getInt( Pskill, PROFESSION_SKILL_USE_FLAG),
            SKILL_getInt(skill,SKILL_IDENTITY),
			PROFESSION_SKILL_getInt( Pskill, PROFESSION_SKILL_TARGET),
		    PROFESSION_SKILL_getInt( Pskill, PROFESSION_SKILL_KIND),
		    PROFESSION_SKILL_getInt( Pskill, PROFESSION_SKILL_ICON),
			cost_mp,
			skill_level,
			PROFESSION_SKILL_getChar( Pskill, PROFESSION_SKILL_NAME),
		    PROFESSION_SKILL_getChar( Pskill, PROFESSION_SKILL_TXT) );


    return ITEM_statusStringBuffer;
}
#else
char* SKILL_makeSkillStatusString( Skill* skill )
{
    snprintf( ITEM_statusStringBuffer,
              sizeof( ITEM_statusStringBuffer ),
              "%d|%d",
              SKILL_getInt(skill,SKILL_IDENTITY),
              SKILL_getInt(skill,SKILL_LEVEL) );


    return ITEM_statusStringBuffer;
}
#endif



char* SKILL_makeSkillFalseString( void )
{
    snprintf( ITEM_statusStringBuffer,
              sizeof( ITEM_statusStringBuffer ),
              "|" );
    return ITEM_statusStringBuffer;
}


BOOL  SKILL_CHECKID( int skillid )
{