/*
* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:     
*
*/






// INCLUDE FILES
#include "SortUtilJapan.h"
#include "SortUtilImpl.h"
#include "SortUtilImplExport.h"
#include <jplangutil.h>

// Unnamed namespace for local definitions
namespace
    {

    /**
     * Character classes for Japanese sorting, in sorting order.
     */
    enum TJapaneseCharClass
        {
        ECharClassKana,
        ECharClassLatin,
        ECharClassDigit,
        ECharClassKanji,
        ECharClassSpecial
        };

    /**
     * Returns the Japanese character class of aChar.
     */
    TJapaneseCharClass CharClass(TUint aChar)
        {
        const TChar ch(aChar);
        // Special characters
        if (ch.IsSpace() || ch.IsPunctuation() || ch.IsControl()
            || aChar >= 0xF0000 && aChar <= 0xFFFD)
            {
            return ECharClassSpecial;
            }
        // Digit
        else if (aChar >= '0' && aChar <= '9' ||
            aChar >= 0xFF10 && aChar <= 0xFF19)
            {
            return ECharClassDigit;
            }
        // Latin
        else if (aChar >= 'A' && aChar <= 'Z' ||
            aChar >= 'a' && aChar <= 'z' ||
            aChar >= 0x00C0 && aChar <= 0x1EF3 && aChar != 0x00D7 && aChar != 0x00F7 ||
            aChar >= 0xFF21 && aChar <= 0xFF3A ||
            aChar >= 0xFF41 && aChar <= 0xFF5A)
            {
            return ECharClassLatin;
            }
        // Kana
        else if (JPLangUtil::IsKatakana(static_cast<TText>(aChar)) ||
            JPLangUtil::IsHiragana(static_cast<TText>(aChar)))
            {
            return ECharClassKana;
            }
        // Kanji
        else if (JPLangUtil::IsKanji(static_cast<TText>(aChar)))
            {
            return ECharClassKanji;
            }
        // All other charcters are "special"
        else
            {
            return ECharClassSpecial;
            }
        }

    /**
     * Compares two characters with Japanese comparison rules.
     */
    TInt JapaneseCompareC(TUint aLhs, TUint aRhs)
        {
        // First compare character classes
        const TInt lhsCls = CharClass(aLhs);
        const TInt rhsCls = CharClass(aRhs);
        return lhsCls - rhsCls;
        }

    /**
     * Compares two strings with Japanese comparison rules.
     */
    TInt JapaneseCompareS(const TDesC& aLhs, const TDesC& aRhs)
        {
        TInt result = 0;

        const TInt minLen = Min(aLhs.Length(), aRhs.Length());
        TInt i;
        TInt prevCompPos(0);
        for (i = 0; i < minLen && result == 0; ++i)
            {
            result = JapaneseCompareC(aLhs[i], aRhs[i]);
            if (result == 0)
                {
                TInt orgClass = CharClass(aLhs[i]);
                TPtrC lPart;
                TPtrC rPart;
                if (orgClass == ECharClassKana)
                    {
                    int j = i;
                    for (; j < aLhs.Length(); ++j)
                        {
                        if (orgClass != CharClass(aLhs[j]))
                            {
                            break;
                            }
                        }
                    lPart.Set(aLhs.Mid(prevCompPos, j - prevCompPos));
                    for (j = i; j < aRhs.Length(); ++j)
                        {
                        if (orgClass != CharClass(aRhs[j]))
                            {
                            break;
                            }
                        }
                    rPart.Set(aRhs.Mid(prevCompPos, j - prevCompPos));
                    result = lPart.CompareC(rPart);
                    if (result != 0)
                        {
                        const TInt minKanaLen = Min(lPart.Length(), rPart.Length());
                        TPtrC lKanaPart(lPart.Left(minKanaLen));
                        TPtrC rKanaPart(rPart.Left(minKanaLen));
                        TInt resultKana = lKanaPart.MatchC(rKanaPart);
                        if (resultKana == 0)
                            {
                            TInt maxKanaLen = i+minKanaLen;
                            if (i+minKanaLen+1 >= minLen)
                                {
                                if (maxKanaLen < aLhs.Length()
                                 || maxKanaLen < aRhs.Length())
                                    {
                                    result = 0;
                                    i += (minKanaLen-1);
                                    }
                                else
                                    {
                                    result = lKanaPart.CompareC(rKanaPart);;
                                    }
                                }
                            else
                                {
                                result = 0;
                                i += (minKanaLen-1);
                                }
                            }
                        }

                    }
                else
                    {
                    lPart.Set(aLhs.Mid(i, 1));
                    rPart.Set(aRhs.Mid(i, 1));
                    result = lPart.CompareC(rPart);
                    }
                }
            else
                {
                prevCompPos = i;
                }
            }
        if (result == 0)
            {
            if (i < aLhs.Length())
                {
                // aLhs is longer than aRhs
                result += User::Collate(aLhs[i]);
                }
            if (i < aRhs.Length())
                {
                // aRhs is longer that aLhs
                result -= User::Collate(aRhs[i]);
                }
            }
        return result;
        }
    }  // namespace

// Only export in DLL
EXPORT_C MSortUtil* SortUtilFactoryFunctionL()
    {
    MSortUtil* util = new (ELeave) TSortUtilJapan;
    return util;
    }

inline TSortUtilJapan::TSortUtilJapan()
    {
    }

TSortUtilJapan::~TSortUtilJapan()
    {
    }

TInt TSortUtilJapan::CompareItems
        (const MSortKeyArray& aLhs,
        const MSortKeyArray& aRhs) const
    {
    TInt result(0);
    TInt lhsIndex(0);
    TInt rhsIndex(0);

    // Compare only pronounciation keys in the first pass
    do
        {
        const TDesC& lhsText =
            SortUtilImpl::FindNextNonEmptyKey(aLhs, ESortKeyPronounciation, lhsIndex);
        const TDesC& rhsText =
            SortUtilImpl::FindNextNonEmptyKey(aRhs, ESortKeyPronounciation, rhsIndex);
        if (lhsText.Length() > 0)
            {
            // lhs has pronounciation key
            if (rhsText.Length() > 0)
                {
                // Both lhs and rhs have pronounciation key: compare the key texts
                result = JapaneseCompareS(lhsText, rhsText);
                }
            else
                {
                // Only lhs has pronounciation key
                result = -1;
                }
            }
        else
            {
            // lhs does not have pronounciation key
            if (rhsText.Length() > 0)
                {
                // Only rhs has pronounciation key
                result = 1;
                }
            }

        if (result != 0)
            {
            return result;
            }
        }
    while (lhsIndex <= aLhs.SortKeyCount() && rhsIndex < aRhs.SortKeyCount());

    // No difference found with pronounciation keys: compare basic keys
    lhsIndex = 0;
    rhsIndex = 0;
    do
        {
        const TDesC& lhsText =
            SortUtilImpl::FindNextNonEmptyKey(aLhs, ESortKeyBasic, lhsIndex);
        const TDesC& rhsText =
            SortUtilImpl::FindNextNonEmptyKey(aRhs, ESortKeyBasic, rhsIndex);
        result = JapaneseCompareS(lhsText, rhsText);
        if (result != 0)
            {
            return result;
            }
        }
    while (lhsIndex <= aLhs.SortKeyCount() && rhsIndex < aRhs.SortKeyCount());

    return result;
    }

// End of file