package org.litesoft.configuration;

import org.litesoft.util.*;

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

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

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

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

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

    public ConfigAccessorLocator( String pRelativeConfigFilePath,
                                  ConfigAccessorFactory pConfigAccessorFactory,
                                  List<String> pAdditionalSearchPaths )
    {
        this( pRelativeConfigFilePath, pConfigAccessorFactory );
        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;
    }

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

    public ConfigDataAccessor createConfigDataAccessor()
    {
        ConfigDataAccessor found = searchForConfigFileInFileSystem();
        if ( found != null )
        {
            return found;
        }
        InputStream is = getClass().getResourceAsStream( mRelativeConfigFilePath );
        if ( is != null )
        {
            try
            {
                ConfigDataAccessor configAccessor = mConfigAccessorFactory.create( null, //
                                                                                   mRelativeConfigFilePath, //
                                                                                   is );
                System.out.println( "Loaded configuration as 'resource': " + mRelativeConfigFilePath );
                return configAccessor;
            }
            catch ( IOException e )
            {
                throw newErrorMessage( "load as 'resource': " + mRelativeConfigFilePath, e );
            }
            finally
            {
                Utils.dispose( is );
            }
        }
        throw newErrorMessage( "locate", null );
    }

    private 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" );
    }

    private 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; // Now going to fail, but if it does, then ignore
            }
        }
        String fileRelativeFrom = locateFile( new File( pParentPath ), mRelativeConfigFilePath );
        if ( fileRelativeFrom == null )
        {
            return null;
        }

        File fileAt = new File( fileRelativeFrom, mRelativeConfigFilePath );
        InputStream is;
        try
        {
            is = new FileInputStream( fileAt );
        }
        catch ( IOException e )
        {
            throw newErrorMessage( "open (" + fileAt.getAbsolutePath() + ")", e );
        }
        try
        {
            ConfigDataAccessor configAccessor =
                    mConfigAccessorFactory.create( fileRelativeFrom, mRelativeConfigFilePath, is );
            System.out.println( "Loaded configuration from: " + fileAt.getAbsolutePath() );
            return configAccessor;
        }
        catch ( IOException e )
        {
            throw newErrorMessage( "load (" + fileAt.getAbsolutePath() + ")", e );
        }
        finally
        {
            Utils.dispose( is );
        }
    }

    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;
    }
}