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

import java.io.*;
import java.util.*;

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

public class ConfigAccessorLocator implements ConfigDataAccessorFactory
{
    public static final String CURRENT_DIR = ".";

    protected final String mRelativeConfigFilePath;
    private ConfigAccessorFactory mConfigAccessorFactory;
    private List<String> mAdditionalSearchPaths = new ArrayList<String>();

    public ConfigAccessorLocator( String pRelativeConfigFilePath, ConfigAccessorFactory pConfigAccessorFactory )
    {
        mRelativeConfigFilePath = Utils.assertNotNullNotEmpty( "RelativeConfigFilePath", pRelativeConfigFilePath ).replace( '\\', '/' );
        Objects.assertNotNull( "ConfigAccessorFactory", mConfigAccessorFactory = pConfigAccessorFactory );
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public ConfigAccessorLocator( String pRelativeConfigFilePath, ConfigAccessorFactory pConfigAccessorFactory, String... pAdditionalSearchPaths )
    {
        this( pRelativeConfigFilePath, pConfigAccessorFactory );
        addSearchPaths( pAdditionalSearchPaths );
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public ConfigAccessorLocator( String pRelativeConfigFilePath, ConfigAccessorFactory pConfigAccessorFactory, List<String> pAdditionalSearchPaths )
    {
        this( pRelativeConfigFilePath, pConfigAccessorFactory );
        addSearchPaths( pAdditionalSearchPaths );
    }

    public ConfigAccessorLocator( String pRelativeConfigFilePath )
    {
        this( pRelativeConfigFilePath, ConfigAccessorFactoryProperties.INSTANCE );
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public ConfigAccessorLocator( String pRelativeConfigFilePath, String... pAdditionalSearchPaths )
    {
        this( pRelativeConfigFilePath );
        addSearchPaths( pAdditionalSearchPaths );
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public ConfigAccessorLocator( String pRelativeConfigFilePath, List<String> pAdditionalSearchPaths )
    {
        this( pRelativeConfigFilePath );
        addSearchPaths( pAdditionalSearchPaths );
    }

    private void addSearchPath( String pSearchPath )
    {
        if ( pSearchPath != null )
        {
            mAdditionalSearchPaths.add( pSearchPath.trim() );
        }
    }

    public ConfigAccessorLocator addSearchPaths( List<String> pSearchPaths )
    {
        if ( pSearchPaths != null )
        {
            for ( String path : pSearchPaths )
            {
                addSearchPath( path );
            }
        }
        return this;
    }

    public ConfigAccessorLocator addSearchPaths( String... pSearchPaths )
    {
        if ( pSearchPaths != null )
        {
            for ( String path : pSearchPaths )
            {
                addSearchPath( path );
            }
        }
        return this;
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public String[] getAdditionalSearchPaths()
    {
        return mAdditionalSearchPaths.toArray( new String[mAdditionalSearchPaths.size()] );
    }

    @Override
    public ConfigDataAccessor createConfigDataAccessor()
    {
        ConfigDataAccessor found = searchForConfigFileInFileSystem();
        if ( found == null )
        {
            if ( null == (found = loadConfigFileAsResource()) )
            {
                throw unableToLocate();
            }
        }
        return found;
    }

    protected RuntimeException unableToLocate()
    {
        return newErrorMessage( "locate", null );
    }

    protected ConfigDataAccessor searchForConfigFileInFileSystem()
    {
        ConfigDataAccessor found = searchForConfigFileAtSystemPropertyUserHomeDir();
        if ( found != null )
        {
            return found;
        }
        for ( String zSearchPath : mAdditionalSearchPaths )
        {
            if ( null != (found = searchForConfigFileAt( zSearchPath )) )
            {
                return found;
            }
        }
        return searchForConfigFileAtSystemPropertyCurrentDir();
    }

    protected ConfigDataAccessor searchForConfigFileAtSystemPropertyUserHomeDir()
    {
        return searchForConfigFileAtSystemProperty( "user.home" );
    }

    protected ConfigDataAccessor searchForConfigFileAtSystemPropertyCurrentDir()
    {
        return searchForConfigFileAtSystemProperty( "user.dir" );
    }

    protected RuntimeException newErrorMessage( String pWhy, Throwable pCause )
    {
        return new IllegalStateException( "Unable to " + pWhy + " '" + mRelativeConfigFilePath + "'," + " looked in the following Hierarchies: " + mCheckedForFileAt, pCause );
    }

    private List<String> mCheckedForFileAt = new ArrayList<String>();

    private ConfigDataAccessor searchForConfigFileAtSystemProperty( String pSystemPropertyReference )
    {
        String value;
        try
        {
            value = System.getProperty( pSystemPropertyReference );
        }
        catch ( SecurityException e )
        {
            return null; // OK so we won't look there!
        }
        return searchForConfigFileAt( value );
    }

    private ConfigDataAccessor searchForConfigFileAt( String pParentPath )
    {
        if ( pParentPath == null )
        {
            return null;
        }
        if ( pParentPath.length() == 0 )
        {
            try
            {
                pParentPath = new File( CURRENT_DIR ).getCanonicalPath();
            }
            catch ( IOException e )
            {
                return null; // Not going to fail, but if it does, then ignore
            }
        }
        String fileRelativeFrom = locateFile( new File( pParentPath ), mRelativeConfigFilePath );
        return (fileRelativeFrom == null) ? null : loadConfigAccessorFrom( new File( fileRelativeFrom, mRelativeConfigFilePath ) );
    }

    protected ConfigDataAccessor loadConfigFileAsResource()
    {
        InputStream is = getClass().getResourceAsStream( mRelativeConfigFilePath );
        return (is == null) ? null : loadConfigAccessorFrom( is, null, "'resource': " + mRelativeConfigFilePath );
    }

    protected ConfigDataAccessor loadConfigAccessorFrom( File fileAt )
    {
        String zFrom = "file: " + fileAt.getAbsolutePath();
        InputStream is;
        try
        {
            is = new FileInputStream( fileAt );
        }
        catch ( IOException e )
        {
            throw newErrorMessage( "open (" + zFrom + ")", e );
        }
        return loadConfigAccessorFrom( is, fileAt.getParent(), zFrom );
    }

    private ConfigDataAccessor loadConfigAccessorFrom( InputStream pIS, String pFromDirectory, String pFrom )
    {
        try
        {
            ConfigDataAccessor configAccessor = mConfigAccessorFactory.create( pFromDirectory, mRelativeConfigFilePath, pIS );
            System.out.println( "Loaded configuration from " + pFrom );
            return configAccessor;
        }
        catch ( IOException e )
        {
            throw newErrorMessage( "load (" + pFrom + ")", e );
        }
        finally
        {
            Utils.dispose( pIS );
        }
    }

    private String locateFile( File pParentPath, String pFile )
    {
        if ( !shouldLookAt( pParentPath ) )
        {
            return null;
        }
        return huntForFile( pParentPath, pFile );
    }

    protected String huntForFile( File pParentPath, String pFile )
    {
        String found;
        while ( null == (found = checkForFileAt( pParentPath, pFile )) )
        {
            pParentPath = pParentPath.getParentFile();
            if ( (pParentPath == null) || !shouldLookAt( pParentPath ) )
            {
                return null;
            }
        }
        return found;
    }

    protected String checkForFileAt( File pParentPath, String pFile )
    {
        return new File( pParentPath, pFile ).isFile() ? pParentPath.getAbsolutePath() : null;
    }

    private boolean shouldLookAt( File pDir )
    {
        String dirPath = pDir.getAbsolutePath().replace( '\\', '/' );
        if ( dirPath.endsWith( "/." ) )
        {
            dirPath = dirPath.substring( 0, dirPath.length() - 2 );
        }
        if ( mCheckedForFileAt.contains( dirPath ) )
        {
            return false;
        }
        mCheckedForFileAt.add( dirPath );
        return true;
    }
}