package org.litesoft.orsup;

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

import org.litesoft.configuration.*;
import org.litesoft.core.*;
import org.litesoft.core.util.*;
import org.litesoft.logger.*;
import org.litesoft.loggerconfig.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.nonpublic.*;
import org.litesoft.sql.*;
import org.litesoft.util.*;

public abstract class DB_Admin
{
    private CmdLineProcessor[] CMDS = //
            { //
              new Create( "create" ), //
              new Drop( "drop" ), //
              new Fresh( "fresh" ), //
              new Populate( "populate" ), //
              new ExportObject( "exportObject" ), //
              new Pause( "pause" ), //
              new ImportCSV( "importCSV" ), //
              new ExportCSV( "exportCSV" ), //
              // new ReCreateIndices( "reCreateIndices" ), //
            };

    public DB_Admin( MetaDataRegistry pRegistry, ConfigDataAccessorFactory pConfigDataAccessorFactory )
    {
        new ServerConfiguration( pConfigDataAccessorFactory ); // force creation & self registration of Configuration
        LoggerFactory.init( new ConfigurationLoggerLevel() );

        DataStore zDataStore = new DataStoreBaseSQL( pRegistry );

        DataStoreLocator.initialize( zDataStore );

        ServerContext.clearAllServerStores();

        ContextID zContextID = new ContextID( "Admin", "Admin" );
        new ServerContext( zContextID, new SimpleMapServerSession() ).set();
    }

    private String help( String pProblem )
    {
        if ( Utils.isNotNullOrEmpty( pProblem ) )
        {
            System.out.println();
            System.out.println( pProblem );
        }
        System.out.println();
        System.out.println( "Usage: java " + getClass().getSimpleName() + " command(s) ..." );
        System.out.println();
        System.out.println( "Where command(s) are one or more of the following:" );
        System.out.println();

        for ( CmdLineProcessor zProcessor : CMDS )
        {
            System.out.println( "   " + zProcessor.helpCMD() );
            if ( Utils.isNotNullOrEmpty( zProcessor.getDescription() ) )
            {
                System.out.println( "       " + zProcessor.getDescription() );
            }
            System.out.println();
        }
        System.exit( -1 );
        return null;
    }

    public CmdLineProcessor getProcessor( String pOperation )
    {
        for ( CmdLineProcessor processor : CMDS )
        {
            if ( processor.getCommand().equalsIgnoreCase( pOperation ) )
            {
                return processor;
            }
        }
        return null;
    }

    protected void processMainArgs( String argv[] )
            throws Exception
    {
        if ( argv.length >= 1 )
        {
            processArgs( new ArrayIterator<String>( argv ) );
            return;
        }
        help( "" );
    }

    private void processArgs( Iterator<String> pArgs )
            throws Exception
    {
        while ( pArgs.hasNext() )
        {
            String zCommand = pArgs.next();

            CmdLineProcessor processor = getProcessor( zCommand );
            if ( processor != null )
            {
                processor.callExecute( pArgs );
                continue;
            }
            help( "Unknown operation - " + zCommand );
        }
    }

    abstract class CmdLineProcessor
    {
        private String mCommand;
        private String mDescription;
        private String[] mParams;
        private Iterator<String> mArgs = null;
        protected int mIndexParams = 0;
        private boolean mIsVarArgs;

        protected CmdLineProcessor( String pCommand, String pDescription, boolean pIsVarArgs, String... pParams )
        {
            mCommand = pCommand;
            mDescription = pDescription;
            mIsVarArgs = pIsVarArgs;
            mParams = (pParams != null) ? pParams : new String[0];
        }

        public String getCommand()
        {
            return mCommand;
        }

        public String getDescription()
        {
            return mDescription;
        }

        public String[] getParams()
        {
            return mParams;
        }

        public final void callExecute( Iterator<String> pArgs )
                throws Exception
        {
            System.out.println( "executing " + getClass().getSimpleName() );
            mArgs = pArgs;
            mIndexParams = 0;
            execute();
        }

        abstract protected void execute()
                throws Exception;

        protected boolean hasAnotherArg()
        {
            return mArgs.hasNext();
        }

        protected String getNextArg()
        {
            if ( mIndexParams < mParams.length )
            {
                return getNextArg( mParams[mIndexParams++] );
            }
            if ( mIsVarArgs )
            {
                return getNextArg( null );
            }
            return help( "Attempt to read more parameters than specified" );
        }

        protected String getNextArg( String pWhat )
        {
            if ( !mIsVarArgs && !mArgs.hasNext() )
            {
                help( "Command '" + getCommand() + "' Missing: " + pWhat );
            }
            return mArgs.next();
        }

        public String helpCMD()
        {
            StringBuilder sb = new StringBuilder( mCommand ).append( ' ' );
            for ( String param : mParams )
            {
                sb.append( param ).append( ' ' );
            }
            return sb.toString();
        }
    }

    private class Create extends CmdLineProcessor
    {
        public Create( String pCommand )
        {
            super( pCommand, "create all tables", false );
        }

        protected final void execute()
                throws Exception
        {
            DataStoreLocator.get().createAllTables();
        }
    }

    private class Populate extends CmdLineProcessor
    {
        public Populate( String pCommand )
        {
            super( pCommand, "Load the DB via the DataLoader", false );
        }

        protected final void execute()
                throws Exception
        {
            DataLoader.INSTANCE.loadData();
        }
    }

    private class ImportCSV extends CmdLineProcessor
    {
        public ImportCSV( String pCommand )
        {
            super( pCommand, "Import CSV file(s) from Dir", false, "LoadDataDir" );
        }

        protected final void execute()
                throws Exception
        {
            DataLoader.INSTANCE.loadDataFrom( Utils.assertNotNullNotEmpty( "LoadDataDir", getNextArg() ) );
        }
    }

    private class ExportCSV extends CmdLineProcessor
    {
        private static final String DESC = "writes all POs in csv format appropriate for re-importing";

        public ExportCSV( String pCommand )
        {
            super( pCommand, DESC, false, "ExportFileName" );
        }

        public void execute()
                throws Exception
        {
            DB_Export.exportCSV( Utils.assertNotNullNotEmpty( "ExportFileName", getNextArg() ) );
        }
    }

    private class Drop extends CmdLineProcessor
    {
        public Drop( String pCommand )
        {
            super( pCommand, "drop all tables", false );
        }

        protected final void execute()
                throws Exception
        {
            DataStoreLocator.get().dropAllTables();
        }
    }

    private class Fresh extends CmdLineProcessor
    {
        public Fresh( String pCommand )
        {
            super( pCommand, "drop and create all tables", false );
        }

        protected final void execute()
                throws Exception
        {
            DataStoreLocator.get().dropAllTables();
            DataStoreLocator.get().createAllTables();
        }
    }

    private class Pause extends CmdLineProcessor
    {
        private static final String DESC = "wait to receive <enter> from console ";

        public Pause( String pCommand )
        {
            super( pCommand, DESC, true );
        }

        @SuppressWarnings({"ResultOfMethodCallIgnored"})
        public void execute()
                throws Exception
        {
            System.out.print( "press <enter> to continue: " );
            System.out.flush();
            System.in.read();
        }
    }

    private class ExportObject extends CmdLineProcessor
    {
        public ExportObject( String pCommand )
        {
            super( pCommand, "writes all objects of specified name(s) in csv format appropriate for re-importing to the specified ExportFileName", //
                   true, "ExportFileName", "ObjectName(s)" );
        }

        public void execute()
                throws Exception
        {
            String zExportFileName = Utils.assertNotNullNotEmpty( "ExportFileName", getNextArg() );
            String zObjectName = Utils.assertNotNullNotEmpty( "ObjectName", getNextArg() );

            DataStore zDS = DataStoreLocator.get();

            MetaDataStore zMDstore = zDS.getMetaDataStore();

            List<MetaDataForPO> zMDs = new ArrayList<MetaDataForPO>();
            zMDs.add( verifyMD( zMDstore, zObjectName ) );
            while ( hasAnotherArg() )
            {
                zMDs.add( verifyMD( zMDstore, Utils.assertNotNullNotEmpty( "ObjectName", getNextArg() ) ) );
            }

            UnfilteringFinder zFinder = zDS.getUnfilteredFinder();

            System.out.println( "Writing to file: " + zExportFileName );
            FileWriter w = new FileWriter( zExportFileName );

            for ( MetaDataForPO zMD : zMDs )
            {
                DB_Export.printObjects( w, zFinder.findAllCursored( zMD.getPOregistrationName(), null ) );
            }
            w.flush();
            w.close();
        }

        private MetaDataForPO verifyMD( MetaDataStore pMDstore, String pObjectName )
        {
            MetaDataForPO zMetaDataForPO = pMDstore.getMetaDataOptionallyByIdentifier( pObjectName );
            if ( zMetaDataForPO == null )
            {
                help( "No Object known by: " + pObjectName );
            }
            return zMetaDataForPO;
        }
    }

//    private class ReCreateIndices extends CmdLineProcessor
//    {
//        public ReCreateIndices( String pCommand )
//        {
//            super( pCommand, "Recreate Database Table Indices", false );
//        }
//
//        protected final void execute()
//                throws Exception
//        {
//            DataStoreLocator.get().reCreateAllTablesIndices();
//        }
//    }
}