/*---------------------------------------------------------------------------*
  Project: Revolution ENC sample demo
  File:    sample.c

  Copyright 2006 Nintendo.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Log: sample.c,v $
  Revision 1.6  08/14/2006 04:31:35  yoshioka_yasuhiro
  Added demos for ENCConvertStringJisToUnicode and ENCConvertStringUnicodeToJis.

  Revision 1.4  08/09/2006 10:37:37  yoshioka_yasuhiro
  Specification change.
  ENCConverString* functions returns a result code,
  and read/write dstlen and srclen.

  Revision 1.3  08/08/2006 10:48:23  yoshioka_yasuhiro
  Fix for specification change.
  Modified termination check.

  Revision 1.1  08/07/2006 06:43:14  yoshioka_yasuhiro
  Initial commit.

  $NoKeywords: $
 *---------------------------------------------------------------------------*/

#include <revolution.h>
#include <revolution/enc.h>

#include "demostrings.h"

int main()
{
    BOOL test_clear = TRUE;
    #define LENGTH 0x100
    
    /* string*/
    {
        /*u8 char8[8];
        u16 char16;
        u8 mbs[8];
        u16 wc;*/
        s32 srclen, dstlen;
        ENCResult err_code;

        /* SJIS str -> UNICODE str */
        OSReport("\n* SJIS str -> UNICODE str *\n");
        srclen = -1;
        err_code = ENCConvertStringSjisToUnicode(NULL, &dstlen, sjis, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            u16 dst[LENGTH];
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            err_code = ENCConvertStringSjisToUnicode(dst, &dstlen, sjis, &srclen);
            if (err_code)
            {
                OSReport("ERROR: %d\n", err_code);
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                test_clear = FALSE;
            }
            else
            {
                s32 i, j;
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                for (i = 0; i < dstlen; ++i)
                {
                    if (dst[i] == uni[i])
                        continue;
                    OSReport("FAILURE\nend @ %d\n", i);
                    OSReport("result\tanswer\n");
                    for (j = 0; j < 8; ++j)
                        OSReport("%#x\t%#x\n", dst[i + j], uni[i + j]);
                    test_clear = FALSE;
                    break;
                }
                if (i == dstlen)
                {
                    OSReport("SUCCESS\nend @ %d\n", i - 1);
                }
            }
        }

        /* UNICODE str -> SJIS str */
        OSReport("\n* UNICODE str -> SJIS str *\n");
        srclen = -1;
        err_code = ENCConvertStringUnicodeToSjis(NULL, &dstlen, uni, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            u8 dst[LENGTH];
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            err_code = ENCConvertStringUnicodeToSjis(dst, &dstlen, uni, &srclen);
            if (err_code)
            {
                OSReport("ERROR: %d\n", err_code);
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                test_clear = FALSE;
            }
            else
            {
                s32 i, j;
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                for (i = 0; i < dstlen; ++i)
                {
                    if (dst[i] == sjis[i])
                        continue;
                    OSReport("FAILURE\nend @ %d\n", i);
                    OSReport("result\tanswer\n");
                    for (j = 0; j < 8; ++j)
                        OSReport("%#x\t%#x\n", dst[i + j], sjis[i + j]);
                    test_clear = FALSE;
                    break;
                }
                if (i == dstlen)
                {
                    OSReport("SUCCESS\nend @ %d\n", i - 1);
                }
            }
        }

        /* JIS str -> SJIS str */
        OSReport("\n* JIS str -> SJIS str *\n");
        srclen = -1;
        err_code = ENCConvertStringJisToSjis(NULL, &dstlen, jis2, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            u8 dst[LENGTH];
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            err_code = ENCConvertStringJisToSjis(dst, &dstlen, jis2, &srclen);
            if (err_code)
            {
                OSReport("ERROR: %d\n", err_code);
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                test_clear = FALSE;
            }
            else
            {
                s32 i, j;
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                for (i = 0; i < dstlen; ++i)
                {
                    if (dst[i] == sjis[i])
                        continue;
                    OSReport("FAILURE\nend @ %d\n", i);
                    OSReport("result\tanswer\n");
                    for (j = 0; j < 8; ++j)
                        OSReport("%#x\t%#x\n", dst[i + j], sjis[i + j]);
                    test_clear = FALSE;
                    break;
                }
                if (i == dstlen)
                {
                    OSReport("SUCCESS\nend @ %d\n", i - 1);
                }
            }
        }

        /* SJIS str -> JIS str */
        OSReport("\n* SJIS str -> JIS str *\n");
        srclen = -1;
        err_code = ENCConvertStringSjisToJis(NULL, &dstlen, sjis, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            u8 dst[LENGTH];
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            err_code = ENCConvertStringSjisToJis(dst, &dstlen, sjis, &srclen);
            if (err_code)
            {
                OSReport("ERROR: %d\n", err_code);
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                test_clear = FALSE;
            }
            else
            {
                s32 i, j;
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                for (i = 0; i < dstlen; ++i)
                {
                    if (dst[i] == jis[i])
                        continue;
                    OSReport("FAILURE\nend @ %d\n", i);
                    OSReport("result\tanswer\n");
                    for (j = 0; j < 8; ++j)
                        OSReport("%#x\t%#x\n", dst[i + j], jis[i + j]);
                    test_clear = FALSE;
                    break;
                }
                if (i == dstlen)
                {
                    OSReport("SUCCESS\nend @ %d\n", i - 1);
                }
            }
        }

        /* JIS str -> UNICODE str */
        OSReport("\n* JIS str -> UNICODE str *\n");
        srclen = -1;
        err_code = ENCConvertStringJisToUnicode(NULL, &dstlen, jis2, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            u16 dst[LENGTH];
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            err_code = ENCConvertStringJisToUnicode(dst, &dstlen, jis2, &srclen);
            if (err_code)
            {
                OSReport("ERROR: %d\n", err_code);
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                test_clear = FALSE;
            }
            else
            {
                s32 i, j;
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                for (i = 0; i < dstlen; ++i)
                {
                    if (dst[i] == uni[i])
                        continue;
                    OSReport("FAILURE\nend @ %d\n", i);
                    OSReport("result\tanswer\n");
                    for (j = 0; j < 8; ++j)
                        OSReport("%#x\t%#x\n", dst[i + j], uni[i + j]);
                    test_clear = FALSE;
                    break;
                }
                if (i == dstlen)
                {
                    OSReport("SUCCESS\nend @ %d\n", i - 1);
                }
            }
        }

        /* UNICODE str -> JIS str */
        OSReport("\n* UNICODE str -> JIS str *\n");
        srclen = -1;
        err_code = ENCConvertStringUnicodeToJis(NULL, &dstlen, uni, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            u8 dst[LENGTH];
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            err_code = ENCConvertStringUnicodeToJis(dst, &dstlen, uni, &srclen);
            if (err_code)
            {
                OSReport("ERROR: %d\n", err_code);
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                test_clear = FALSE;
            }
            else
            {
                s32 i, j;
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                for (i = 0; i < dstlen; ++i)
                {
                    if (dst[i] == jis[i])
                        continue;
                    OSReport("FAILURE\nend @ %d\n", i);
                    OSReport("result\tanswer\n");
                    for (j = 0; j < 8; ++j)
                        OSReport("%#x\t%#x\n", dst[i + j], jis[i + j]);
                    test_clear = FALSE;
                    break;
                }
                if (i == dstlen)
                {
                    OSReport("SUCCESS\nend @ %d\n", i - 1);
                }
            }
        }

        /* LATIN1 str -> UNICODE str */
        OSReport("\n* LATIN1 str -> UNICODE str *\n");
        srclen = -1;
        err_code = ENCConvertStringLatin1ToUnicode(NULL, &dstlen, latin1, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            u16 dst[LENGTH];
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            err_code = ENCConvertStringLatin1ToUnicode(dst, &dstlen, latin1, &srclen);
            if (err_code)
            {
                OSReport("ERROR: %d\n", err_code);
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                test_clear = FALSE;
            }
            else
            {
                s32 i, j;
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                for (i = 0; i < dstlen; ++i)
                {
                    if (dst[i] == uni1[i])
                        continue;
                    OSReport("FAILURE\nend @ %d\n", i);
                    OSReport("result\tanswer\n");
                    for (j = 0; j < 8; ++j)
                        OSReport("%#x\t%#x\n", dst[i + j], uni1[i + j]);
                    test_clear = FALSE;
                    break;
                }
                if (i == dstlen)
                {
                    OSReport("SUCCESS\nend @ %d\n", i - 1);
                }
            }
        }

        /* UNICODE str -> LATIN1 str */
        OSReport("\n* UNICODE str -> LATIN1 str *\n");
        srclen = -1;
        err_code = ENCConvertStringUnicodeToLatin1(NULL, &dstlen, uni1, &srclen);
        if (err_code)
        {
            OSReport("ERROR: %d\n", err_code);
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            test_clear = FALSE;
        }
        else
        {
            u8 dst[LENGTH];
            OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
            err_code = ENCConvertStringUnicodeToLatin1(dst, &dstlen, uni1, &srclen);
            if (err_code)
            {
                OSReport("ERROR: %d\n", err_code);
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                test_clear = FALSE;
            }
            else
            {
                s32 i, j;
                OSReport("dstlen: %d, srclen: %d\n", dstlen, srclen);
                for (i = 0; i < dstlen; ++i)
                {
                    if (dst[i] == latin1[i])
                        continue;
                    OSReport("FAILURE\nend @ %d\n", i);
                    OSReport("result\tanswer\n");
                    for (j = 0; j < 8; ++j)
                        OSReport("%#x\t%#x\n", dst[i + j], latin1[i + j]);
                    test_clear = FALSE;
                    break;
                }
                if (i == dstlen)
                {
                    OSReport("SUCCESS\nend @ %d\n", i - 1);
                }
            }
        }
    }
    
    /* character*/
    {
        u8 char8[8];
        u16 char16;
        u8 mbs[8];
        u16 wc;
        s32 srclen, dstlen;
        ENCResult err_code;
        
        *mbs = 0x94;
        *(mbs + 1) = 0x43;
        wc = 0x4EFB;
        /* SJIS char -> UNICODE char */
        OSReport("\n* SJIS char -> UNICODE char *\n");
        srclen = 2;
        dstlen = 1;
        err_code = ENCConvertStringSjisToUnicode(&char16, &dstlen, mbs, &srclen);
        if (char16 == wc)
        {
            OSReport("SUCCESS\n");
        }
        else
        {
            OSReport("FAILURE\n");
            test_clear = FALSE;
        }
        OSReport("%#x, %#x -> %#x\n", *mbs, *(mbs + 1), char16);
        
        /* UNICODE char -> SJIS char */
        OSReport("\n* UNICODE char -> SJIS char *\n");
        srclen = 1;
        err_code = ENCConvertStringUnicodeToSjis(NULL, &dstlen, &wc, &srclen);
        err_code = ENCConvertStringUnicodeToSjis(char8, &dstlen, &wc, &srclen);
        if (*char8 == *mbs && *(char8 + 1) == *(mbs + 1))
        {
            OSReport("SUCCESS\n");
        }
        else
        {
            OSReport("FAILURE\n");
            test_clear = FALSE;
        }
        OSReport("%#x -> %#x, %#x\n", wc, *char8, *(char8 + 1));
        
        /* SJIS char -> JIS char */
        *mbs = 0x94;
        *(mbs + 1) = 0x43;
        OSReport("\n* SJIS char -> JIS char *\n");
        srclen = 2;
        err_code = ENCConvertStringSjisToJis(NULL, &dstlen, mbs, &srclen);
        err_code = ENCConvertStringSjisToJis(char8, &dstlen, mbs, &srclen);
        if (*(char8 + 3) == 0x47 && *(char8 + 4) == 0x24)
        {
            OSReport("SUCCESS\n");
        }
        else
        {
            OSReport("FAILURE\n");
            test_clear = FALSE;
        }
        OSReport("%#x, %#x -> %#x, %#x\n", *mbs, *(mbs + 1), *(char8 + 3), *(char8 + 4));
        
        /* JIS char -> SJIS char */
        *mbs = 0x1B;
        *(mbs + 1) = 0x24;
        *(mbs + 2) = 0x42;
        *(mbs + 3) = 0x47;
        *(mbs + 4) = 0x24;
        *(mbs + 5) = 0x1B;
        *(mbs + 6) = 0x28;
        *(mbs + 7) = 0x42;
        OSReport("\n* JIS char -> SJIS char *\n");
        srclen = 8;
        err_code = ENCConvertStringJisToSjis(NULL, &dstlen, mbs, &srclen);
        err_code = ENCConvertStringJisToSjis(char8, &dstlen, mbs, &srclen);
        if (*char8 == 0x94 && *(char8 + 1) == 0x43)
        {
            OSReport("SUCCESS\n");
        }
        else
        {
            OSReport("FAILURE\n");
            test_clear = FALSE;
        }
        OSReport("%#x, %#x -> %#x, %#x\n", *mbs, *(mbs + 1), *char8, *(char8 + 1));
    }
    {
        u8 char8;
        u16 char16;
        u8 lc;
        u16 wc;
        s32 srclen, dstlen;
        s32 err_code;

        lc = 0x80;
        wc = 0x20AC;
        /* LATIN1 char -> UNICODE char */
        OSReport("\n* LATIN1 char -> UNICODE char *\n");
        srclen = 1;
        dstlen = 1;
        err_code = ENCConvertStringLatin1ToUnicode(&char16, &dstlen, &lc, &srclen);
        if (char16 == wc)
        {
            OSReport("SUCCESS\n");
        }
        else
        {
            OSReport("FAILURE\n");
            test_clear = FALSE;
        }
        OSReport("%#x -> %#x\n", lc, wc);
        
        /* UNICODE char -> LATIN1 char */
        OSReport("\n* UNICODE char -> LATIN1 char *\n");
        srclen = 1;
        dstlen = 1;
        err_code = ENCConvertStringUnicodeToLatin1(&char8, &dstlen, &wc, &srclen);
        if (char8 == lc)
        {
            OSReport("SUCCESS\n");
        }
        else
        {
            OSReport("FAILURE\n");
            test_clear = FALSE;
        }
        OSReport("%#x -> %#x\n", wc, char8);
    }
    
    if (test_clear)
        OSReport("\nTOTAL SUCCESS\n");
    else
        OSReport("\nTOTAL FAILURE\n");

    return 0;
}