/*
* Copyright (c) 2007 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:   Implementation of Miscallaneous service functions
*
*/



#include <e32std.h>
#include <uri8.h>
#include <uriutils.h>
#include <authority8.h>
#include <delimitedpath8.h>
//#include <e32const.h>

#include "vccmiscutils.h"
#include "rubydebug.h"

_LIT( KVCCSIPScheme, "sip" );
_LIT( KVCCSIPSScheme, "sips" );
_LIT( KVCCHTTPScheme, "http" );
_LIT( KVCCHTTPSScheme, "https" );

const TUint KAt = '@';

const TInt KVCCMinVDNLength = 5; 

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// Checks if 16 bit reference is valid URI (VDI).
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TVCCMiscUtils::URIValidL( const TDesC16& aURI )
    {
    RUBY_DEBUG_BLOCK( "TVCCMiscUtils::URIValidL()" );
    
    TUriParser parser;
    // Check if uri contains multiple @ characters
    TUint atcount( 0 );
    for( TUint i(0); i<aURI.Length(); i++ )
        {
        if(  KAt == aURI[i] )
             {
             ++atcount;
             }
        }
    
    if( atcount>1 )
       {
       return KErrUnknown;
       }
      
    
    // Parse the URI
    TInt err = parser.Parse( aURI );
    
    if ( !err )
        {
        // Check for invalid characters
        // 0x00-0x1F and > 0x7F), space (0x20), delimiter characters ('<', '>', 
        // '#', '%', '"') and unwise characters ('{', '}', '|', '\', '^', '[', 
        // ']', '`') are illegal
        if ( !UriUtils::HasInvalidChars( aURI ) )
            {
            // Check if scheme is valid
            if ( parser.IsSchemeValid() )
                {
                // Extract the scheme for comparing
                const TDesC& scheme = parser.Extract( EUriScheme );
                
                // SIP or SIPS scheme
                if ( scheme.Compare( KVCCSIPScheme ) == 0 || 
                     scheme.Compare( KVCCSIPSScheme ) == 0 )
                    {
                    err = parser.Validate();
                    }
                // HTTP or HTTPS scheme
                else if ( scheme.Compare( KVCCHTTPScheme ) == 0 || 
                          scheme.Compare( KVCCHTTPSScheme ) == 0 )
                    {
                    // Do nothing at the moment.
                    }
                else
                    {
                    err = KErrUnknown;
                    }
                }
            // No scheme, maybe a host type
            else
                {
                UriUtils::TUriHostType type = UriUtils::HostType( aURI );
                
                switch ( type )
                    {
                    case UriUtils::EIPv6Host:
                    case UriUtils::EIPv4Host:
                    case UriUtils::ETextHost:
                        break;
                    default:
                        {
                        err = KErrUnknown;
                        break;
                        }
                    } // switch
                } // else
            } // if invalid characters
        else
            {
            err = KErrNotSupported;
            }
        }
    
    return err;
    }

// ---------------------------------------------------------------------------
// Checks if reference is valid VDN.
// ---------------------------------------------------------------------------
//
EXPORT_C TBool TVCCMiscUtils::VDNValidL(  const TDesC16& aVDN )
    {
    RUBY_DEBUG_BLOCK( "TVCCMiscUtils::VDNValidL()" );
    
    TBool retVal( ETrue );
    TLex input( aVDN );
    TInt numCount( 0 );
    
    // Is the string empty
    if ( aVDN.Length() > 0 )
        {
        input.Mark();
        
        // Deal with the '+' -sign at the beginning of the string
        if (input.Peek() == '+')
            {
            // Step forward
            input.Inc();
            }
      
        for ( ;; numCount++ )
            {
            if ( !( input.Peek().IsDigit() ) && !( input.Peek().Eos() ) )
                {
                // Next character is not a digit or end-of-string character
                retVal = EFalse;
                break;
                }
            else if ( input.Peek().Eos() && numCount < KVCCMinVDNLength )
                {
                // End of string but number count is too small to be a valid VDN
                retVal = EFalse;
                break;
                }
            else if ( input.Peek().Eos() && numCount >= KVCCMinVDNLength )
                {
                // At the end of string and number count is acceptable to be a
                // valid VDN
                break;
                }
            else
                {
                // step forward
                input.Inc();                
                }
            } // for
        }
    else
        {
        // Empty string
        retVal = EFalse;
        }
    
    return retVal;
    }