// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.util;

import java.io.*;
import java.lang.reflect.*;
import java.net.*;
import java.sql.*;

import org.litesoft.commonfoundation.base.*;
import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.commonfoundation.typeutils.Objects;
import org.litesoft.core.util.*;

@SuppressWarnings({"UnusedDeclaration"})
public class Utils
{
    /**
     * True if running on a Mac OS.
     */
    public static final boolean isMac = System.getProperty( "os.name" ).toLowerCase().contains( "mac os x" );

    /**
     * True if running on a Windows OS.
     */
    public static final boolean isWindows = System.getProperty( "os.name" ).toLowerCase().contains( "windows" );

    public static void pause( int pMillisecs )
            throws RuntimeInterruptedException
    {
        try
        {
            Thread.sleep( pMillisecs );
        }
        catch ( InterruptedException e )
        {
            throw new RuntimeInterruptedException( e );
        }
    }

    public static String getLocalHostName()
    {
        try
        {
            return InetAddress.getLocalHost().getHostName();
        }
        catch ( UnknownHostException e )
        {
            return "Unknown";
        }
    }

    public static String getLocalMachineName()
    {
        String machine = getLocalHostName();
        int firstDot = machine.indexOf( '.' );
        if ( firstDot < 0 )
        {
            return machine;
        }
        return machine.substring( 0, firstDot );
    }

    public static String getLocalHostAddress()
    {
        String zlocalhostAddr;
        try
        {
            InetAddress zLocalInetAddress = InetAddress.getLocalHost();
            zlocalhostAddr = zLocalInetAddress.getHostAddress();
        }
        catch ( UnknownHostException e )
        {
            zlocalhostAddr = "Unknown";
        }
        return zlocalhostAddr;
    }

    /**
     * Find an Available Server Port where pStartSearchWith <= Found Port <= pEndSearchWithbetween.
     *
     * @param pStartSearchWith bottom of search limit (inclusive)
     * @param pEndSearchWith   top of search limit (inclusive)
     *
     * @return !null means the found port, null means none was available in the allowed range
     */
    public static Integer findAvailableServerPort( int pStartSearchWith, int pEndSearchWith )
    {
        assertValidServerPort( pStartSearchWith );
        assertValidServerPort( pEndSearchWith );
        for ( int zPort = pStartSearchWith; zPort <= pEndSearchWith; zPort++ )
        {
            if ( isServerPortAvailable( zPort ) )
            {
                return zPort;
            }
        }
        return null;
    }

    /**
     * Assert that pPort is with the valid range
     *
     * @param pPort must be between 1 and 65535 (inclusive)
     */
    public static void assertValidServerPort( int pPort )
    {
        if ( (pPort < 1) || (0xFFFF < pPort) )
        {
            throw new IllegalArgumentException( "Invalid Port Number: " + pPort );
        }
    }

    /**
     * Check if pPort is an Available Server Port
     *
     * @param pPort must be between 1 and 65535 (inclusive)
     *
     * @return true if able to create a TCP & Datagram Server Socket on pPort
     */
    public static boolean isServerPortAvailable( int pPort )
    {
        assertValidServerPort( pPort );

        ServerSocket ss = null;
        try
        {
            ss = new ServerSocket( pPort );
            ss.setReuseAddress( true );
        }
        catch ( IOException e )
        {
            return false;
        }
        finally
        {
            if ( ss != null )
            {
                try
                {
                    ss.close();
                }
                catch ( IOException e )
                {
                    /* should not be thrown */
                }
            }
        }
        DatagramSocket ds = null;
        try
        {
            ds = new DatagramSocket( pPort );
            ds.setReuseAddress( true );
        }
        catch ( IOException e )
        {
            return false;
        }
        finally
        {
            if ( ds != null )
            {
                ds.close();
            }
        }
        return true;
    }

    public static String dirPath( String pPath )
    {
        if ( pPath != null )
        {
            if ( new File( pPath ).isDirectory() )
            {
                if ( !Paths.endsWithSep( pPath ) )
                {
                    pPath += "/";
                }
            }
            else
            {
                int at = Paths.lastSepAt( pPath );
                if ( at == -1 )
                {
                    pPath = "./";
                }
                else
                {
                    pPath = pPath.substring( 0, at + 1 );
                }
            }
        }
        return pPath;
    }

    public static String relativePath( String pBasePath, String pPossibleRelativePath )
    {
        if ( (pPossibleRelativePath == null) || (pPossibleRelativePath.indexOf( ':' ) != -1) || Characters.isPathSep( pPossibleRelativePath.charAt( 0 ) ) )
        {
            return pPossibleRelativePath;
        }
        return dirPath( pBasePath ) + pPossibleRelativePath;
    }

    public static boolean isNoise( Throwable pThrowable )
    {
        return (pThrowable instanceof UndeclaredThrowableException) || //
               (pThrowable instanceof InvocationTargetException);
    }

    public static List<Throwable> getAllThrowables( Throwable pThrowable )
    {
        ArrayList<Throwable> rv = new ArrayList<Throwable>();
        if ( pThrowable != null )
        {
            addAll( rv, pThrowable );
        }
        return rv;
    }

    private static void addAll( List<Throwable> pAll, Throwable pThrowable )
    {
        while ( pThrowable != null )
        {
            if ( pAll.contains( pThrowable ) )
            {
                return;
            }
            pAll.add( pThrowable );
            if ( pThrowable instanceof SQLException )
            {
                addAll( pAll, ((SQLException) pThrowable).getNextException() );
            }
            pThrowable = pThrowable.getCause();
        }
    }

    /**
     * Create an OutputStream from the pOutputStreamFactory and after copying the data from the pInputStream to the created OutputStream, close both.
     *
     * @param pInputStream         if !null data copied to OutputStream created by pOutputStreamFactory and will be closed!
     * @param pOutputStreamFactory if null will throw null pointer exception, otherwise the OutputStream it creates will be closed!
     */
    public static void copy( InputStream pInputStream, OutputStreamFactory pOutputStreamFactory )
            throws IOException
    {
        OutputStream zOutputStream = null;
        try
        {
            zOutputStream = pOutputStreamFactory.createOutputStream();
            if ( pInputStream != null )
            {
                byte[] buffer = new byte[4096];
                for ( int bytesRead; -1 != (bytesRead = pInputStream.read( buffer )); )
                {
                    if ( bytesRead > 0 )
                    {
                        zOutputStream.write( buffer, 0, bytesRead );
                    }
                }
                InputStream zIS = pInputStream;
                pInputStream = null;
                zIS.close();
            }
            zOutputStream.flush();
            OutputStream zOS = zOutputStream;
            zOutputStream = null;
            zOS.close();
        }
        finally
        {
            dispose( pInputStream );
            dispose( zOutputStream );
        }
    }

    public static void dispose( Closeable pCloseable )
    {
        if ( pCloseable != null )
        {
            try
            {
                pCloseable.close();
            }
            catch ( IOException e )
            {
                // Whatever
            }
        }
    }

    public static BufferedReader getBufferedReader( Reader pReader )
    {
        if ( pReader == null )
        {
            return null;
        }
        if ( pReader instanceof BufferedReader )
        {
            return (BufferedReader) pReader;
        }
        return new BufferedReader( pReader );
    }

    public static <T, U> Map<T, U> addKeyValuesTo( Map<T, U> pMap, Object... pProperty_NameValues )
            throws IllegalArgumentException
    {
        if ( Objects.isNotNullOrEmpty( pProperty_NameValues ) )
        {
            if ( (pProperty_NameValues.length & 1) != 0 )
            {
                throw new IllegalArgumentException( "Attempt to add Properties that were NOT Name/Value pairs" );
            }
            for ( int i = 0; i < pProperty_NameValues.length; i += 2 )
            {
                put( pMap, pProperty_NameValues[i], pProperty_NameValues[i + 1] );
            }
        }
        return pMap;
    }

    @SuppressWarnings({"unchecked"})
    private static <T, U> void put( Map<T, U> pMap, Object pKey, Object pValue )
    {
        pMap.put( (T) pKey, (U) pValue );
    }

    public static String toStringEmptyIfNullOrAppend( Object pPrintObject, String pAppend )
    {
        if ( pPrintObject == null )
        {
            return "";
        }
        return toString( pPrintObject ) + pAppend;
    }

    public static String toStringEmptyIfNullOrPrependAndAppend( String pPrepend, Object pPrintObject, String pAppend )
    {
        if ( pPrintObject == null )
        {
            return "";
        }
        return pPrepend + toString( pPrintObject ) + pAppend;
    }

    public static String toString( Object pObject )
    {
        StringBuilder sb = new StringBuilder();
        sbAppend( sb, pObject );
        return sb.toString();
    }

    public static void sbAppend( StringBuilder pSB, Object pObject )
    {
        if ( pObject == null )
        {
            pSB.append( "null" );
        }
        else if ( pObject.getClass().isArray() )
        {
            sbAppendArrayObject( pSB, pObject );
        }
        else if ( pObject instanceof Collection )
        {
            sbAppend( pSB, (Collection<?>) pObject );
        }
        else if ( pObject instanceof Map )
        {
            sbAppend( pSB, (Map<?, ?>) pObject );
        }
        else // Default (Last Resort)...
        {
            pSB.append( pObject.toString() );
        }
    }

    private static void sbAppend( StringBuilder pSB, Collection<?> pCollection )
    {
        pSB.append( '[' );
        sbAppendArray( pSB, pCollection.toArray() );
        pSB.append( ']' );
    }

    private static void sbAppend( StringBuilder pSB, Map<?, ?> pMap )
    {
        pSB.append( '{' );

        Object[] keys = pMap.keySet().toArray();
        if ( keys.length != 0 )
        {
            sbAppendMapEntry( pSB, pMap, keys[0] );
            for ( int i = 1; i < keys.length; i++ )
            {
                pSB.append( ", " );
                sbAppendMapEntry( pSB, pMap, keys[i] );
            }
        }
        pSB.append( '}' );
    }

    private static void sbAppendMapEntry( StringBuilder pSB, Map<?, ?> pMap, Object pKey )
    {
        sbAppend( pSB, pKey );
        pSB.append( '=' );
        //noinspection SuspiciousMethodCalls
        sbAppend( pSB, pMap.get( pKey ) );
    }

    private static void sbAppendArrayObject( StringBuilder pSB, Object pObject )
    {
        pSB.append( '<' );
        if ( pObject instanceof Object[] )
        {
            sbAppendArray( pSB, (Object[]) pObject );
        }
        else if ( pObject instanceof byte[] )
        {
            sbAppendArray( pSB, (byte[]) pObject );
        }
        else if ( pObject instanceof char[] )
        {
            sbAppendArray( pSB, (char[]) pObject );
        }
        else if ( pObject instanceof double[] )
        {
            sbAppendArray( pSB, (double[]) pObject );
        }
        else if ( pObject instanceof float[] )
        {
            sbAppendArray( pSB, (float[]) pObject );
        }
        else if ( pObject instanceof int[] )
        {
            sbAppendArray( pSB, (int[]) pObject );
        }
        else if ( pObject instanceof long[] )
        {
            sbAppendArray( pSB, (long[]) pObject );
        }
        else if ( pObject instanceof short[] )
        {
            sbAppendArray( pSB, (short[]) pObject );
        }
        else if ( pObject instanceof boolean[] )
        {
            sbAppendArray( pSB, (boolean[]) pObject );
        }
        else // Default (Last Resort)...
        {
            pSB.append( '?' );
            pSB.append( pObject );
            pSB.append( '?' );
        }
        pSB.append( '>' );
    }

    private static void sbAppendArray( StringBuilder pSB, Object[] pObjects )
    {
        if ( pObjects.length != 0 )
        {
            sbAppend( pSB, pObjects[0] );
            for ( int i = 1; i < pObjects.length; i++ )
            {
                pSB.append( ", " );
                sbAppend( pSB, pObjects[i] );
            }
        }
    }

    private static void sbAppendArray( StringBuilder pSB, byte[] pPrimitives )
    {
        if ( pPrimitives.length != 0 )
        {
            pSB.append( pPrimitives[0] );
            for ( int i = 1; i < pPrimitives.length; i++ )
            {
                pSB.append( ',' );
                pSB.append( pPrimitives[0] );
            }
        }
    }

    private static void sbAppendArray( StringBuilder pSB, char[] pPrimitives )
    {
        if ( pPrimitives.length != 0 )
        {
            pSB.append( pPrimitives[0] );
            for ( int i = 1; i < pPrimitives.length; i++ )
            {
                pSB.append( ',' );
                pSB.append( pPrimitives[0] );
            }
        }
    }

    private static void sbAppendArray( StringBuilder pSB, double[] pPrimitives )
    {
        if ( pPrimitives.length != 0 )
        {
            pSB.append( pPrimitives[0] );
            for ( int i = 1; i < pPrimitives.length; i++ )
            {
                pSB.append( ',' );
                pSB.append( pPrimitives[0] );
            }
        }
    }

    private static void sbAppendArray( StringBuilder pSB, float[] pPrimitives )
    {
        if ( pPrimitives.length != 0 )
        {
            pSB.append( pPrimitives[0] );
            for ( int i = 1; i < pPrimitives.length; i++ )
            {
                pSB.append( ',' );
                pSB.append( pPrimitives[0] );
            }
        }
    }

    private static void sbAppendArray( StringBuilder pSB, int[] pPrimitives )
    {
        if ( pPrimitives.length != 0 )
        {
            pSB.append( pPrimitives[0] );
            for ( int i = 1; i < pPrimitives.length; i++ )
            {
                pSB.append( ',' );
                pSB.append( pPrimitives[0] );
            }
        }
    }

    private static void sbAppendArray( StringBuilder pSB, long[] pPrimitives )
    {
        if ( pPrimitives.length != 0 )
        {
            pSB.append( pPrimitives[0] );
            for ( int i = 1; i < pPrimitives.length; i++ )
            {
                pSB.append( ',' );
                pSB.append( pPrimitives[0] );
            }
        }
    }

    private static void sbAppendArray( StringBuilder pSB, short[] pPrimitives )
    {
        if ( pPrimitives.length != 0 )
        {
            pSB.append( pPrimitives[0] );
            for ( int i = 1; i < pPrimitives.length; i++ )
            {
                pSB.append( ',' );
                pSB.append( pPrimitives[0] );
            }
        }
    }

    private static void sbAppendArray( StringBuilder pSB, boolean[] pPrimitives )
    {
        if ( pPrimitives.length != 0 )
        {
            pSB.append( pPrimitives[0] );
            for ( int i = 1; i < pPrimitives.length; i++ )
            {
                pSB.append( ',' );
                pSB.append( pPrimitives[0] );
            }
        }
    }

    public static String fixPercentsInURLs( String pURLtext )
    {
        if ( pURLtext != null )
        {
            int zFrom = 0;
            for ( int zAt; -1 != (zAt = pURLtext.indexOf( '%', zFrom )); zFrom = zAt + 1 )
            {
                if ( pURLtext.length() <= (zAt + 2) )
                {
                    break;
                }
                int zHi = Hex.fromChar( pURLtext.charAt( zAt + 1 ) );
                int zLo = Hex.fromChar( pURLtext.charAt( zAt + 2 ) );
                if ( (zHi != -1) && (zLo != -1) )
                {
                    pURLtext = pURLtext.substring( 0, zAt ) + //
                               ((char) ((zHi * 16) + zLo)) + //
                               pURLtext.substring( zAt + 3 );
                }
            }
        }
        return pURLtext;
    }
}