/*

* Copyright 2010 Keng-Yu Lin <kengyu@lexical.tw>

*

* This file is part of Array31.

*

* Array31 is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* Array31 is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with Array31. If not, see <http://www.gnu.org/licenses/>.

*/

#include "aarraylex.h"

#include "acandidatewindows.h"

#include <Windows.h>

#include <sstream>

AArrayLex::AArrayLex( wstring primary, wstring secondary, wstring simple, bool useSimpleCandidate, int nkey )

:state( 0 ), root( 0 ), backable( false ), parent( 0 ), simpleCodeReady( false ), nKey( 31 )

{

AArrayLex::useSimpleCandidate = useSimpleCandidate;

nKey = nkey;

// get module path

wchar_t path[ 256 ];

int szPath;

szPath = GetModuleFileNameW( ACandidateWindow::hInstance, path, 255 );

int l( 0 );

for( int i = 0; i < szPath; ++i )

if( path[i] == L'\\' )

l = i;

path[ l + 1 ] = 0;

mPath = path;

// init root

root = new struct Node;

state = root;

root->desc.resize( nKey );

//root->desc = new struct Node * [ nKey ];

for( int i = 0; i < nkey; ++i )

root->desc[ i ] = 0;

if( primary != L"" ) tinit( mPath + primary, false );

if( secondary != L"" ) tinit( mPath + secondary, true );

if( simple != L"" )

{

sinit( mPath + simple );

simpleCodeReady = true;

}

}

AArrayLex::~AArrayLex()

{

if( root )

tdelete( root );

}

int AArrayLex::put( int asciikey )

{

// reset

if( asciikey == 0 )

{

state = root;

parent = 0;

backable = false;

return ST_RESET;

}

struct Node * sdesc = state->desc[ getStrokeNumFromChar( asciikey ) ];

if( sdesc )

{

parent = state;

backable = true;

state = sdesc;

return ST_VALID;

}

else

{

//state = root;

return ST_RESET;

}

}

void AArrayLex::back()

{

if( backable )

{

state = parent;

backable = false;

}

}

vector<wchar_t> AArrayLex::getCandidates( wchar_t ascii )

{

vector<wchar_t> candidates = state->characters;

if( simpleCodeReady && parent == root && ascii != 0 && simpleCode.find( ascii ) != simpleCode.end() )

for( int i = state->characters.size(); i < simpleCode[ ascii ].size(); ++i )

candidates.push_back( simpleCode[ ascii ].at( i ) );

else if( useSimpleCandidate )

for( int i = state->characters.size(); i < 10; ++i )

candidates.push_back( getOneChild( state, i + 1 ) );

return candidates;

}

wstring AArrayLex::getCandidateString( wchar_t ascii )

{

wstring cstring;

vector<wchar_t> & canvec = getCandidates( ascii );

for( int i = 1; i <= canvec.size(); ++i )

{

std::wstringstream ss;

if( i == 10 )

ss << L"0" ;

else

ss << i;

if( canvec.at( i - 1 ) == 0 )

cstring += ss.str() + L"□ ";

else

cstring += ss.str() + canvec.at( i - 1 ) + L" ";

}

return cstring;

}

wchar_t AArrayLex::getOneChild( struct Node * node, int n )

{

vector<wchar_t> c;

if( n == 1 )

{

c.push_back( 'Q' ); c.push_back( 'A' ); c.push_back( 'Z' );

}

else if ( n == 2 )

{

c.push_back( 'W' ); c.push_back( 'S' ); c.push_back( 'X' );

}

else if ( n == 3 )

{

c.push_back( 'E' ); c.push_back( 'D' ); c.push_back( 'C' );

}

else if ( n == 4 )

{

c.push_back( 'R' ); c.push_back( 'F' ); c.push_back( 'V' );

}

else if ( n == 5 )

{

c.push_back( 'T' ); c.push_back( 'G' ); c.push_back( 'B' );

}

else if ( n == 6 )

{

c.push_back( 'Y' ); c.push_back( 'H' ); c.push_back( 'N' );

}

else if ( n == 7 )

{

c.push_back( 'U' ); c.push_back( 'J' ); c.push_back( 'M' );

}

else if ( n == 8 )

{

c.push_back( 'I' ); c.push_back( 'K' ); c.push_back( ',' );

}

else if ( n == 9 )

{

c.push_back( 'O' ); c.push_back( 'L' ); c.push_back( '.' );

}

else if ( n == 0 )

{

c.push_back( 'P' ); c.push_back( ';' ); c.push_back( '/' );

}

for( vector<wchar_t>::iterator i = c.begin(); i != c.end(); ++i )

{

struct Node * sdesc = node->desc[ getStrokeNumFromChar( * i ) ];

if( sdesc && sdesc->characters.size() != 0 )

return sdesc->characters[0];

}

return 0;

}

void AArrayLex::tinit( wstring & fi, bool ext )

{

FILE * fs;

_wfopen_s( & fs, fi.c_str(), L"r" );

ifstream f( fs );

if( ! f )

{

}

put( 0 );

char s[256];

wchar_t ws[256];

int szws;

while( f.getline( s, 255 ) )

{

// szws include null terminator

szws = MultiByteToWideChar( CP_UTF8, 0, s, -1, ws, 255 );

wstringstream ss;

ss << ws;

wstring stroke; wchar_t character;

ss >> character >> stroke;

if( ext )

stroke += L"I";

tmake( root, 0, stroke, character );

}

}

void AArrayLex::sinit( wstring & fi )

{

FILE * fs;

_wfopen_s( & fs, fi.c_str(), L"r" );

ifstream f( fs );

if( ! f )

{

}

char s[256];

wchar_t ws[256];

int szws;

while( f.getline( s, 255 ) )

{

// szws include null terminator

szws = MultiByteToWideChar( CP_UTF8, 0, s, -1, ws, 255 );

wstringstream ss;

ss << ws;

wstring codestr; wchar_t code;

ss >> code >> codestr;

simpleCode.insert( make_pair( code, codestr ) );

}

}

void AArrayLex::tmake( struct Node * node, int strokeIndex, const wstring & stroke, const wchar_t & ch )

{

if( strokeIndex == stroke.size() )

{

node->characters.push_back( ch );

return;

}

int strokeNum = getStrokeNumFromChar( stroke.at( strokeIndex ) );

if( node->desc[ strokeNum ] == 0 )

{

struct Node * child = new struct Node;

//child->desc = new struct Node * [ nKey ];

child->desc.resize( nKey );

for( int i = 0; i < nKey; ++i )

child->desc[ i ] = 0;

node->desc[ strokeNum ] = child;

}

tmake( node->desc[ strokeNum ], strokeIndex + 1, stroke, ch );

}

void AArrayLex::tdelete( struct Node * node )

{

if( node == 0 )

node = root;

for( int i = 0; i < nKey; ++i )

if( node->desc[ i ] != 0 )

{

tdelete( node->desc[ i ] );

delete node->desc[ i ];

}

//delete node->desc;

}

int AArrayLex::getStrokeNumFromChar( wchar_t c )

{

if( nKey == 10 )

{

return c - 48;

}

else

{

if( c == 44 ) // `

return 0;

else if( c == 46 ) // .

return 1;

else if( c == 47 ) // /

return 2;

else if( c == 59 ) // ;

return 3;

else if( c >= 65 && c <= 90 ) // A-Z

return c - 61;

else if( c == 96 ) // `

return 30;

else if( c >= 48 && c <= 57 ) // 0-9

return c - 17;

else

return -1;

}

}

wchar_t AArrayLex::getStrokeCharFromNum( int n )

{

if( nKey == 10 )

{

return n - 48;

}

else

{

if( n == 0 )

return 44;

else if( n == 1 )

return 46;

else if( n == 2 )

return 47;

else if( n == 3 )

return 59;

else if( n > 3 && n < 30 ) // A-Z

return n + 61;

else if( n == 40 ) // `

return 96;

else if( n >= 31 && n <= 40 ) // 0-9

return n + 17;

else

return -1;

}

}