/*****************************************************************************************
*                                                                                       *
* COPYRIGHT:                                                                            *
*   (C) Copyright International Business Machines Corporation,  2001                    *
*   Licensed Material - Program-Property of IBM - All Rights Reserved.                  *
*   US Government Users Restricted Rights - Use, duplication, or disclosure             *
*   restricted by GSA ADP Schedule Contract with IBM Corp.                              *
*                                                                                       *
*****************************************************************************************
************************************************************************
*   Date        Name        Description
*   03/20/2000   Madhu        Creation.
************************************************************************/

#include "ittrans.h"
#include "jahatrts.h"
#include "unicode/utypes.h"
#include "unicode/translit.h"
#include "unicode/jamohang.h"
#include "unicode/unifilt.h"
#include "unicode/unicode.h"
#include "intltest.h"
#include <stdio.h>
#include <string.h>
/*converts a Unicodestring to integer*/
static int32_t getInt(UnicodeString str)
{
  int32_t result = 0;
  int32_t len = str.length();
  int32_t i = 0;
  for(i=0; i<len; i++) {
    result = result*10+u_charDigitValue(str.char32At(i));
  }
  return result;
}
//---------------------------------------------
// runIndexedTest
//---------------------------------------------

void JamoToHangTransliteratorTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
    if (exec) logln((UnicodeString)"TestSuite JamoToHangul Transliterator API ");
    switch (index) {
     
        case 0: name = "TestConstruction"; if (exec) TestConstruction(); break;
        case 1: name = "TestCloneEqual"; if (exec) TestCloneEqual(); break;
        case 2: name = "TestSimpleTransliterate"; if (exec) TestSimpleTransliterate(); break;
        case 3: name = "TestTransliterate"; if (exec) TestTransliterate(); break;
        case 4: name = "TestTransliterate2"; if (exec) TestTransliterate2(); break;
        default: name = ""; break; /*needed to end loop*/
    }
}

// This test used to call handleTransliterate.  That is a protected
// method that isn't supposed to be called externally.  This method is
// a workaround to make it call the correct method.
static void pseudoHandleTransliterate(const Transliterator* t,
                                      Replaceable& text,
                                      UTransPosition& index,
                                      UBool incremental) {
    if (incremental) {
        UErrorCode status = U_ZERO_ERROR;
        t->transliterate(text, index, status);
    } else {
        t->finishTransliteration(text, index);
    }
}

/**
 * Used by TestConstruction() and TestTransliterate.
 */
class TestJamoFilter : public UnicodeFilter {
    virtual UnicodeMatcher* clone() const {
        return new TestJamoFilter(*this);
    }
    virtual UBool contains(UChar32 c) const {
       if(c == 0x1101 )
          return FALSE;
       else
          return TRUE;
    }
};
void JamoToHangTransliteratorTest::TestConstruction(){
    logln("Testing the construction JamoHangulTransliterator()");
    JamoHangulTransliterator *trans1=new JamoHangulTransliterator();
    if(trans1 == 0){
        errln("JamoHangulTransliterator() construction failed.");
        return;
    }

    JamoHangulTransliterator *trans2=new JamoHangulTransliterator(new TestJamoFilter);
    if(trans2 == 0){
        errln("JamoHangulTransliterator(UnicodeFilter) construction failed.");
        return;
    }
    logln("Testing copy construction");
    JamoHangulTransliterator *trans2copy=new JamoHangulTransliterator(*trans2);
    if(trans2copy == 0){
        errln("JamoHangulTransliterator copy construction failed");
        delete trans2;
    }

    if(trans2copy->getID() != trans2->getID() ||
        trans2copy->getFilter() == NULL || 
        trans2copy->getFilter()->contains(0x1101) != trans2->getFilter()->contains(0x1101) ) {
        errln("Copy construction failed");
    }


    delete trans1;
    delete trans2copy;
    delete trans2;

}
void JamoToHangTransliteratorTest::TestCloneEqual(){
    logln("Testing the clone and =operator of JamoHangulTransliterator");
    JamoHangulTransliterator *trans1=new JamoHangulTransliterator();
    if(trans1 == 0){
        errln("JamoHangulTransliterator() construction failed.");
        return;
    }
    JamoHangulTransliterator *trans2=new JamoHangulTransliterator(new TestJamoFilter);
    if(trans2 == 0){
        errln("JamoHangulTransliterator(UnicodeFilter) construction failed.");
        return;
    }

    JamoHangulTransliterator *trans1equal=new JamoHangulTransliterator();
    JamoHangulTransliterator *trans2equal=new JamoHangulTransliterator();
    *trans1equal=*trans1;
    *trans2equal=*trans2;
    if(trans1equal == 0 || trans2equal==0 ){
        errln("=Operator failed");
        delete trans1;
        delete trans2;
        return;
    }
    if(trans1->getID() != trans1equal->getID() ||
        trans1equal->getFilter() != NULL   || 
        trans2->getID() != trans2equal->getID() ||
        trans2equal->getFilter() == NULL  ||
        trans2equal->getFilter()->contains(0x1101) != trans2->getFilter()->contains(0x1101) ) {
        errln("=Operator failed");
    }


    JamoHangulTransliterator *trans1clone=(JamoHangulTransliterator*)trans1->clone();
    JamoHangulTransliterator *trans2clone=(JamoHangulTransliterator*)trans2->clone();
    if(trans1clone == 0 || trans2clone==0 ){
        errln("clone() failed");
        delete trans1;
        delete trans2;
        return;
    }
    if(trans1->getID() != trans1clone->getID() ||
        trans1clone->getFilter() != NULL   || 
        trans2->getID() != trans2clone->getID() ||
        trans2clone->getFilter() == NULL  ||
        trans2clone->getFilter()->contains(0x1101) != trans2->getFilter()->contains(0x1101) ) {
        errln("=Operator failed");
    }

    delete trans1;
    delete trans2;
    delete trans1equal;
    delete trans2equal;
}

void JamoToHangTransliteratorTest::TestSimpleTransliterate(){
    logln("Testing the handleTransliterate() of JamoHangulTransliterator");
    JamoHangulTransliterator *trans1=new JamoHangulTransliterator();
    if(trans1==0){
        errln("JamoHangulTransliterator construction failed");
        return;
    }
    UChar src[]={ 0x1101, 0x1109, 0x1166, 0x11A8, 0x11AD, 0x116D, 0};
    UnicodeString source(src);
    UnicodeString expected(CharsToUnicodeString("\\uAE4C\\uC139\\uC54A\\uC694"));
    expect(*trans1, "", source, expected);

    JamoHangulTransliterator *trans2=new JamoHangulTransliterator(new TestJamoFilter);
    if(trans2==0){
        errln("JamoHangulTransliterator(UnicodeFilter) construction failed");
        return;
    }
    expect(*trans2, " with Filter(0x1101) ",  source, CharsToUnicodeString("\\u1101\\uC139\\uC54A\\uC694"));


}
void JamoToHangTransliteratorTest::TestTransliterate2(){
    logln("Testing the handleTransliterate() of JamoHangulTransliterator");
    JamoHangulTransliterator *trans1=new JamoHangulTransliterator();
    if(trans1==0){
        errln("JamoHangulTransliterator construction failed");
        return;
    }
    UnicodeString source, expected, temp;
    UChar choseong=0x1100;
    UChar jungseong=0x1161;
    UChar jongseong=0x11a8;
    for(UChar c=0xac01;c<0xacff;++c){
        source.append(choseong);
        if(jongseong > 0x11c2){
            jongseong=0x11a8;
            jungseong++;
            source.append(jungseong);
        }
        else {
            source.append(jungseong);
            source.append(jongseong++);
        }
        expected.append(c);

        expect(*trans1, "",  source, expected);
        source.remove();
        expected.remove();

    }
}
void JamoToHangTransliteratorTest::TestTransliterate(){
    UnicodeString Data[]={
    // source, index.contextStart, index.contextLimit, index.start, expectedResult, expectedResult using Filter(TestJamoFilter)
        CharsToUnicodeString("\\u1100\\u1101\\u1102"), "1", "3", "1", CharsToUnicodeString("\\u1100\\uAE4C\\uB098"), CharsToUnicodeString("\\u1100\\u1101\\uB098"),
        CharsToUnicodeString("\\u1167\\u1101"), "0", "1", "0",  CharsToUnicodeString("\\uc5ec\\u1101"), CharsToUnicodeString("\\uc5ec\\u1101"),
        CharsToUnicodeString("\\u1167\\u1101"), "0", "2", "0",  CharsToUnicodeString("\\uc5ec\\uae4c"), CharsToUnicodeString("\\uc5ec\\u1101"),

    };
    uint32_t i;
    JamoHangulTransliterator *trans1=new JamoHangulTransliterator();
    if(trans1 == 0){
        errln("JamoHangulTransliterator construction failed");
        return;
    }
    JamoHangulTransliterator *trans2=new JamoHangulTransliterator(new TestJamoFilter);
    if(trans2 == 0){
        errln("JamoHangulTransliterator(UnicodeFilter) construction failed");
        return;
    }
    for(i=0;i<sizeof(Data)/sizeof(Data[0]);i=i+6){
        expectTranslit(*trans1, ":", Data[i+0], getInt(Data[i+1]), getInt(Data[i+2]), getInt(Data[i+3]), Data[i+4] );
        expectTranslit(*trans2, " with Filter(0x1101):", Data[i+0], getInt(Data[i+1]), getInt(Data[i+2]), getInt(Data[i+3]), Data[i+5] );

    }
    delete trans1;
    delete trans2;

}
//======================================================================
// Support methods
//======================================================================

void JamoToHangTransliteratorTest::expectTranslit(const JamoHangulTransliterator& t,
                                                  const UnicodeString& message,
                                                  const UnicodeString& source, 
                                                  int32_t start, int32_t limit, int32_t cursor,
                                                  const UnicodeString& expectedResult)
{


    UTransPosition _index;
    _index.contextStart= start;
    _index.contextLimit = limit;
    _index.start = cursor;
    _index.limit = limit;
    UTransPosition index;
    index = _index;
    UnicodeString rsource(source);
    pseudoHandleTransliterate(&t, rsource, index, FALSE);
    expectAux(t.getID() + ":handleTransliterator(increment=FALSE) " + message, source + "-->" + rsource, rsource==expectedResult, expectedResult);

    UnicodeString rsource2(source);
    index=_index;
    pseudoHandleTransliterate(&t, rsource2, index, TRUE);
    expectAux(t.getID() + ":handleTransliterator(increment=TRUE) " + message, source + "-->" + rsource2, rsource2==expectedResult, expectedResult);

    /*ceates a copy constructor and checks the transliteration*/
    JamoHangulTransliterator *copy=new JamoHangulTransliterator(t);
    rsource2.remove();
    rsource2.append(source);
    index=_index;
    pseudoHandleTransliterate(copy, rsource2, index, FALSE);
    expectAux(t.getID() + "COPY:handleTransliterator(increment=FALSE) "+ message, source + "-->" + rsource2, rsource2==expectedResult, expectedResult);

    rsource2.remove();
    rsource2.append(source);
    index=_index;
    pseudoHandleTransliterate(copy, rsource2, index, TRUE);
    expectAux(t.getID() + "COPY:handleTransliterator(increment=TRUE) "+ message, source + "-->" + rsource2, rsource2==expectedResult, expectedResult);
    delete copy;

    /*creates a clone and tests transliteration*/
    JamoHangulTransliterator *clone=(JamoHangulTransliterator*)t.clone();
    rsource2.remove();
    rsource2.append(source);
    index=_index;
    pseudoHandleTransliterate(clone, rsource2, index, FALSE);
    expectAux(t.getID() + "CLONE:handleTransliterator(increment=FALSE) "+ message, source + "-->" + rsource2, rsource2==expectedResult, expectedResult);

    rsource2.remove();
    rsource2.append(source);
    index=_index;
    pseudoHandleTransliterate(clone, rsource2, index, TRUE);
    expectAux(t.getID() + "CLONE:handleTransliterator(increment=TRUE) "+ message, source + "-->" + rsource2, rsource2==expectedResult, expectedResult);

    /*Uses the assignment operator to create a transliterator and tests transliteration*/
    JamoHangulTransliterator equal=t;
    rsource2.remove();
    rsource2.append(source);
    index=_index;
    pseudoHandleTransliterate(&equal, rsource2, index, FALSE);
    expectAux(t.getID() + "=OPERATOR:handleTransliterator(increment=FALSE) "+ message, source + "-->" + rsource2, rsource2==expectedResult, expectedResult);

    rsource2.remove();
    rsource2.append(source);
    index=_index;
    pseudoHandleTransliterate(&equal, rsource2, index, TRUE);
    expectAux(t.getID() + "=OPERATOR:handleTransliterator(increment=TRUE) "+ message, source + "-->" + rsource2, rsource2==expectedResult, expectedResult);

    delete clone;

}
void JamoToHangTransliteratorTest::expect(const JamoHangulTransliterator& t,
                                        const UnicodeString& message,
                                        const UnicodeString& source,
                                        const UnicodeString& expectedResult)
{

    UnicodeString rsource(source);
    t.transliterate(rsource);
    expectAux(t.getID() + ":Replaceable " + message, source + "->" + rsource, rsource==expectedResult, expectedResult);

    // Test handleTransliterate (incremental) transliteration -- 
    rsource.remove();
    rsource.append(source);
    UTransPosition index;
    index.contextStart =0;
    index.contextLimit=source.length();
    index.start=0;
    index.limit=source.length();
    pseudoHandleTransliterate(&t, rsource, index, TRUE);
    expectAux(t.getID() + ":handleTransliterate " + message, source + "->" + rsource, rsource==expectedResult, expectedResult);

}
void JamoToHangTransliteratorTest::expectAux(const UnicodeString& tag,
                                   const UnicodeString& summary, UBool pass,
                                   const UnicodeString& expectedResult) {
    if (pass) {
        logln(UnicodeString("(")+tag+") " + prettify(summary));
    } else {
        errln(UnicodeString("FAIL: (")+tag+") "
              + prettify(summary)
              + ", expected " + prettify(expectedResult));
    }
}