// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.orsup;

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

import java.io.*;
import java.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 ) {
        ConfigDataAccessor zAccessor = pConfigDataAccessorFactory.createConfigDataAccessor();
        zAccessor.overrideAllStartingWith( LoggerLevel.CONFIGURATION_BASE + ".", "Warn" );
        zAccessor.setKeyValue( ConfigDataAccessor.Level.RUN, LoggerLevel.CONFIGURATION_BASE + ".org.litesoft.orsup.DB_Import", "Info" );

        new ServerConfiguration( new ServerConfigDataAccessorFactoryProxy( zAccessor ) ); // force creation & self registration of Configuration
        LoggerFactory.init( new ConfigurationLoggerLevel() );

        DataStore zDataStore = new DataStoreBaseSQL( pRegistry );

        DataStoreLocator.initialize( zDataStore );

        ServerStores.clear();

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

    private String help( String pProblem ) {
        if ( Currently.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 ( Currently.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 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 );
        }

        @Override
        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 );
        }

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

        @Override
        protected final void execute()
                throws Exception {
            DataLoader.INSTANCE.loadDataFrom( Confirm.significant( "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" );
        }

        @Override
        public void execute()
                throws Exception {
            DB_Export.exportCSV( Confirm.significant( "ExportFileName", getNextArg() ) );
        }
    }

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

        @Override
        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 );
        }

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

        @Override
        public void execute()
                throws Exception {
            String zExportFileName = Confirm.significant( "ExportFileName", getNextArg() );
            String zObjectName = Confirm.significant( "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, Confirm.significant( "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();
//        }
//    }
}