/*
 * Copyright (c) 1994  Sony Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL SONY CORPORATION BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * Except as contained in this notice, the name of Sony Corporation
 * shall not be used in advertising or otherwise to promote the sale, use
 * or other dealings in this Software without prior written authorization
 * from Sony Corporation.
 *
 */

#include "common.h"
#include "key.h"
#include "wchar16.h"
#define YOMILEN 32
#define KLEN 64

extern struct valtbl hin_val[];

extern int keyvalue;

exec_toroku() {
	Conversion* cv;
	wchar16_t   yomi[YOMILEN + 1], kanji[KLEN + 1];
	wchar16_t*  hinshi;
	int	    inc;
	int	    h_code, retv;
	int	    val;

	if(IsDcflag())
		return (0);
	cv  = GetConversion();
	val = getkstr(kanji, KLEN, WCGtoroku);
	if(*kanji == '\0')
		return (val);

	while(1) {
		if(getyomi(yomi, YOMILEN, WCGtoroku, kanji) || *yomi == '\0')
			break;
		h_code = gethinshi();
		hinshi = hin_val[h_code - 1].keyword;
		if(getcheck(yomi, kanji, hinshi, WCGtoroku))
			break;
	}
	if(*yomi == '\0')
		return (val);

	TopGuide();
	printR(WCGtoroku);
	Clear_EOL();
	Flush();
	cv->word_regist = 1;
	if((retv = SJ2_toroku(yomi, kanji, hin_val[h_code - 1].ivalue)) != 0) {
		switch(retv) {
		case -1:
			(void)dconnect(0);
			return (val);
		case SJ3_WORD_EXIST:
			SJ_print(WCExist);
			break;
		case SJ3_BAD_YOMI_STR:
			SJ_print(WCYomiTouroku);
			break;
		case SJ3_BAD_KANJI_STR:
			SJ_print(WCKanjiTouroku);
			break;
		case SJ3_DOUON_FULL:
			SJ_print(WCOnajiTouroku);
			break;
		case SJ3_DICT_FULL:
			SJ_print(WCUserTouroku);
			break;
		case SJ3_DICT_LOCKED:
			SJ_print(WCJishoLock);
			break;
		default:
			SJ_print(WCSystemError);
			break;
		}
	} else
		SJ_print(WCTOUROKU_SUCC);
	Clear_EOL();
	Flush();

	inc = inkey();
	if(AnotherConversion()) {
		unget_key(inc);
	}
	return (val);
}

getyomi(yomi, lim, prompt, kanji)
    wchar16_t* yomi,
    *prompt, *kanji;
int lim;
{
	int	      inc, c;
	Conversion*   cv;
	int	      len;
	wchar16_t     wtmp[BUFFLENGTH], ytmp[YOMILEN + 1], ktmp[KLEN + 1];
	unsigned char tmp[BUFFLENGTH];

	cv = GetConversion();
	TopGuide();
	printR(prompt);
	len = cv->column - (wcbyte(kanji) + 24);
	if(len >= lim) {
		(void)wcstombs((char*)ytmp, WCMyomi, YOMILEN + 1);
		(void)wcstombs((char*)ktmp, kanji, KLEN + 1);
		sprintf((char*)tmp, (char*)ytmp, ktmp);
		(void)mbstowcs(wtmp, (char*)tmp, BUFFLENGTH);
	} else {
		(void)wcstombs((char*)ytmp, WCMyomi, YOMILEN + 1);
		(void)sprintf((char*)tmp, (char*)ytmp);
		(void)mbstowcs(wtmp, (char*)tmp, BUFFLENGTH);
	}

	SJ_print(wtmp);
	Clear_EOL();
	Flush();

	*wtmp = '\0';
	*tmp  = '\0';
	*yomi = '\0';
	wrap_off();
	SaveConversion();
	while((inc = inkey()) != EOF) {
		if(AnotherConversion()) {
			unget_key(inc);
			sj3_rkclear();
			wrap_on();
			return (1);
		}
		if(keyvalue == KEY_CONV) {
			sj3_rkclear();
			wrap_on();
			return (1);
		}
		if(keyvalue == KEY_KETTEI || keyvalue == KEY_HENKAN) {
			break;
		} else if(keyvalue != KEY_NORMAL) {
			if((c = write_pseq(2)) != 0)
				inc = c;
		}

		if(inc == '\n' || inc == '\r' || IsESC(inc))
			break;
		else if(iscntrl(inc) && !is_bs(inc))
			beep();
		else if((len = wslen(wtmp)) >= lim && !is_bs(inc))
			beep();
		else
			(void)exec_romaji2(inc, NULL, wtmp, NULL, len, -1);
	}
	(void)exec_romaji2(0, NULL, wtmp, NULL, wslen(wtmp), -1);
	wscpy(yomi, wtmp);
	sj3_rkclear();
	wrap_on();
	return (0);
}

gethinshi() {
	int inc, hcode;

	TopGuide();
	printR(WCGtoroku);
	SJ_print(WCTOUROKU_HIN);
	Clear_EOL();
	SJ_print(WCOne);
	Backspace();
	Flush();
	inc = inkey();
	if(inc >= '2' && inc <= '5')
		hcode = inc - '0';
	else
		hcode = 1;
	return (hcode);
}

getcheck(yomi, kanji, hinshi, prompt)
    wchar16_t* yomi,
    *kanji, *hinshi, *prompt;
{
	int		  c;
	unsigned char	  tmp[BUFFLENGTH + KLEN];
	extern wchar16_t* Y;
	wchar16_t	  wtmp[BUFFLENGTH + KLEN];
	unsigned char	  ktmp[KLEN + 1], ytmp[YOMILEN + 1], htmp[YOMILEN + 1],
	    ttmp[BUFFLENGTH];

	TopGuide();
	printR(prompt);
	if(hinshi == NULL) {
		(void)wcstombs((char*)ktmp, kanji, KLEN + 1);
		(void)wcstombs((char*)ytmp, yomi, YOMILEN + 1);
		(void)wcstombs((char*)ttmp, WCSHOUKYO_OK, BUFFLENGTH);
		sprintf((char*)tmp, (char*)ttmp, ktmp, ytmp);
	} else {
		(void)wcstombs((char*)ktmp, kanji, KLEN + 1);
		(void)wcstombs((char*)ytmp, yomi, YOMILEN + 1);
		(void)wcstombs((char*)htmp, hinshi, YOMILEN + 1);
		(void)wcstombs((char*)ttmp, WCTOUROKU_OK, BUFFLENGTH);
		sprintf((char*)tmp, (char*)ttmp, ktmp, ytmp, htmp);
	}

	(void)mbstowcs(wtmp, (char*)tmp, BUFFLENGTH + KLEN);
	SJ_print(wtmp);
	Clear_EOL();
	SJ_print(WCY);
	Backspace();
	Flush();

	SaveConversion();
	c = inkey();
	if(AnotherConversion()) {
		unget_key(c);
		return (0);
	}

	if(keyvalue == KEY_CONV) {
		*yomi = '\0';
		return (1);
	}

	if(c == 'y' || c == 'Y' || c == '\n' || c == '\r' || c == ' ')
		return (1);
	if(keyvalue == KEY_HENKAN || keyvalue == KEY_KETTEI)
		return (1);
	if(IsESC(c)) {
		*yomi = '\0';
		return (1);
	}
	return (0);
}

getkstr(s, lim, guide)
    wchar16_t* s,
    *guide;
int lim;
{
	Conversion* cv;
	int	    i;
	wchar16_t   tmp[BUFFLENGTH * 2];
	wchar16_t*  p;
	int	    plen, chbun;

	chbun = 0;
	cv    = GetConversion();
	if(cv->Kanji != 0) {
		if(cv->Bnum > 1) {
			Ssbun(0);
			chbun++;
			plen = getbunsetsu(tmp, guide);
		} else
			plen = Bkanji(tmp);
	} else if(isspaned()) {
		plen = cv->out_point;
		Strncpy(tmp, cv->out_buf, plen);
		tmp[plen] = '\0';
	}
	p = tmp;
	for(i = 0; i < plen && i < lim; i++)
		*(s++) = *(p++);
	*s = '\0';
	return (chbun);
}

getbunsetsu(kanji, guide)
    wchar16_t* kanji,
    *guide;
{
	Conversion*    cv;
	int	       c;
	int	       bstart, bend;
	int	       i;
	unsigned short row, col;
	wchar16_t*     p;
	int	       plen, len;

	cv     = GetConversion();
	len    = 0;
	p      = kanji;
	*p     = '\0';
	bstart = bend = cv->CurBun;

	StartGuide(&row, &col);
	printR(guide);
	SJ_print(WCMhani);
	Clear_EOL();
	EndGuide(row, col);
	Flush();
	SaveConversion();
	while((c = inkey()) != EOF) {
		if(AnotherConversion()) {
			unget_key(c);
			return (0);
		}
		cv = GetConversion();
		if(keyvalue == KEY_RIGHT) {
			if((bend == bstart) && (bend < cv->Bnum - 1)) {
				cv->PreBun = bend;
				bend++;
				cv->CurBun = bstart = bend;
				Rdisp();
			} else
				beep();
		} else if(keyvalue == KEY_LEFT) {
			if((bend == bstart) && (bend > 0)) {
				cv->PreBun = bend;
				bend--;
				cv->CurBun = bstart = bend;
				Rdisp();
			} else
				beep();
		} else if(keyvalue == KEY_UP) {
			if(bend < cv->Bnum - 1) {
				bend++;
				cv->CurBun = cv->PreBun = bend;
				Rdisp();
			} else
				beep();
		} else if(keyvalue == KEY_DOWN) {
			if(bend > bstart) {
				cv->PreBun = bend;
				bend--;
				cv->CurBun = bend;
				Rdisp();
			} else
				beep();
		} else if(keyvalue == KEY_HENKAN || keyvalue == KEY_KETTEI ||
			  keyvalue == KEY_FLUSH) {
			break;
		} else if(keyvalue == KEY_NORMAL) {
			if(c == '\n' || c == '\r') {
				bstart = 0;
				bend   = cv->Bnum - 1;
				break;
			} else if(c == ' ') {
				break;
			} else if(IsESC(c)) {
				return (0);
			} else
				beep();
		} else
			beep();
		Flush();
	}

	for(i = bstart; i <= bend; i++) {
		if((plen = Bstr(i, p)) <= 0)
			continue;
		p += plen;
		len += plen;
	}
	return (len);
}

exec_shoukyo() {
	int	      i;
	wchar16_t     yomi[YOMILEN + 1], kanji[KLEN + 1];
	wchar16_t     tmp[BUFFLENGTH], tmp2[BUFFLENGTH * 2];
	unsigned char ytmp[YOMILEN + 1], ktmp[KLEN + 1],
	    mtmp[BUFFLENGTH], mtmp2[BUFFLENGTH * 2],
	    ttmp[BUFFLENGTH];
	int inc;
	int val, retv;

	if(IsDcflag())
		return (0);
	val = getkstr(kanji, KLEN, WCGshoukyo);
	if(*kanji == '\0')
		return (val);

	while(1) {
		if(getyomi(yomi, YOMILEN, WCGshoukyo, kanji) || *yomi == '\0')
			break;
		if(getcheck(yomi, kanji, NULL, WCGshoukyo))
			break;
	}
	if(*yomi == '\0')
		return (val);

	TopGuide();
	printR(WCGshoukyo);
	tmp[0] = '\0';
	for(i = 0; i < 5; i++) {
		retv = SJ2_shoukyo(yomi, kanji, hin_val[i].ivalue);
		if(retv == 0) {
			wscat(tmp, hin_val[i].keyword);
			wscat(tmp, WCKanma);
		} else if(retv != SJ3_WORD_NOT_EXIST)
			break;
	}
	if(tmp[0] == '\0') {
		switch(retv) {
		case -1:
			(void)dconnect(0);
			return (val);
		case SJ3_WORD_NOT_EXIST:
			SJ_print(WCNotExist);
			break;
		case SJ3_DICT_LOCKED:
			SJ_print(WCUserLock);
			break;
		case SJ3_BAD_YOMI_STR:
			SJ_print(WCYomiShokyo);
			break;
		case SJ3_BAD_KANJI_STR:
			SJ_print(WCKanjiShokyo);
			break;
		default:
			SJ_print(WCShokyoError);
			break;
		}
	} else {
		i	   = wslen(tmp);
		tmp[i - 1] = '\0';
		(void)wcstombs((char*)mtmp, tmp, BUFFLENGTH);
		(void)wcstombs((char*)ytmp, yomi, YOMILEN + 1);
		(void)wcstombs((char*)ktmp, kanji, KLEN + 1);
		(void)wcstombs((char*)ttmp, WCSHOUKYO_SUCC, BUFFLENGTH);
		sprintf((char*)mtmp2, (char*)ttmp, ktmp, ytmp, mtmp);
		(void)mbstowcs(tmp2, (char*)mtmp2, BUFFLENGTH * 2);
		SJ_print(tmp2);
	}
	Clear_EOL();
	Flush();

	inc = inkey();
	if(AnotherConversion()) {
		unget_key(inc);
	}
	return (val);
}