/**
      This file is part of GoldenGate Project (named also GoldenGate or GG).
   
      Copyright 2009, Frederic Bregier, and individual contributors by the @author
      tags. See the COPYRIGHT.txt in the distribution for a full listing of
      individual contributors.
   
      All GoldenGate Project is free software: you can redistribute it and/or 
      modify it under the terms of the GNU General Public License as published 
     by the Free Software Foundation, either version 3 of the License, or
     (at your option) any later version.
  
     GoldenGate is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
  
     You should have received a copy of the GNU General Public License
     along with GoldenGate .  If not, see <http://www.gnu.org/licenses/>.
   */
  package openr66.commander;
  
  import java.io.File;
  import java.util.concurrent.ConcurrentLinkedQueue;
  
  import goldengate.common.database.data.AbstractDbData;
  import goldengate.common.database.data.AbstractDbData.UpdatedInfo;
  import goldengate.common.database.exception.GoldenGateDatabaseException;
  import goldengate.common.logging.GgInternalLogger;
  import goldengate.common.logging.GgInternalLoggerFactory;
  import openr66.configuration.ExtensionFilter;
  import openr66.database.data.DbConfiguration;
  import openr66.database.data.DbHostAuth;
  import openr66.database.data.DbRule;
  import openr66.database.data.DbTaskRunner;
  import openr66.protocol.configuration.Configuration;
  import openr66.protocol.utils.FileUtils;
  import openr66.protocol.utils.OpenR66SignalHandler;
  
  /**
   * Commander is responsible to read list of updated data from time to time in order to
   * achieve new runner or new configuration updates.
   *
   * Based on no Database support
   *
   * @author Frederic Bregier
   *
   */
  public class CommanderNoDb implements CommanderInterface {
      /**
       * Internal Logger
       */
      private static final GgInternalLogger logger = GgInternalLoggerFactory
              .getLogger(CommanderNoDb.class);
  
      private InternalRunner internalRunner = null;
      public static final ConcurrentLinkedQueue<AbstractDbData> todoList = new ConcurrentLinkedQueue<AbstractDbData>();
  
      /**
       * Prepare requests that will be executed from time to time
       * @param runner
       */
      public CommanderNoDb(InternalRunner runner) {
          this.internalConstructor(runner);
      }
      /**
       * Prepare requests that will be executed from time to time
       * @param runner
       * @param fromStartup True if call from startup of the server
       */
      public CommanderNoDb(InternalRunner runner, boolean fromStartup) {
          this.internalConstructor(runner);
          if (fromStartup) {
              ClientRunner.activeRunners = new ConcurrentLinkedQueue<ClientRunner>();
              // Change RUNNING or INTERRUPTED to TOSUBMIT since they should be ready
              /*
              Configuration.configuration.baseDirectory+
              Configuration.configuration.archivePath+R66Dir.SEPARATOR+
              this.requesterHostId+"_"+this.requestedHostId+"_"+this.ruleId+"_"+this.specialId
              +XMLEXTENSION;
               */
              File directory = new File(Configuration.configuration.baseDirectory+
                      Configuration.configuration.archivePath);
              File[] files = FileUtils.getFiles(directory,
                      new ExtensionFilter(DbTaskRunner.XMLEXTENSION));
              for (File file: files) {
                  String shortname = file.getName();
                  String []info = shortname.split("_");
                  if (info.length < 5) {
                      continue;
                  }
                  DbRule rule;
                  try {
                      rule = new DbRule(null, info[2]);
                  } catch (GoldenGateDatabaseException e) {
                      logger.warn("Cannot find the rule named: "+info[2]);
                      continue;
                  }
                  long id = Long.parseLong(info[3]);
                 try {
                     DbTaskRunner task = new DbTaskRunner(null, null, rule, id, info[0], info[1]);
                     UpdatedInfo status = task.getUpdatedInfo();
                     if (status == UpdatedInfo.RUNNING || status == UpdatedInfo.INTERRUPTED) {
                         task.changeUpdatedInfo(UpdatedInfo.TOSUBMIT);
                         task.update();
                     }
                 } catch (GoldenGateDatabaseException e) {
                     logger.warn("Cannot reload the task named: "+shortname);
                     continue;
                 }
             }
         }
     }
     private void internalConstructor(InternalRunner runner) {
         internalRunner = runner;
     }
     /**
      * Finalize internal data
      */
     public void finalize() {
         // no since it will be reloaded
         //todoList.clear();
     }
 
     /* (non-Javadoc)
      * @see java.lang.Runnable#run()
      */
     @Override
     public void run() {
         Thread.currentThread().setName("OpenR66Commander");
         while (! todoList.isEmpty()) {
             try {
                 AbstractDbData data = todoList.poll();
                 // First check Configuration
                 if (data instanceof DbConfiguration) {
                  // should be only one...
                     DbConfiguration configuration = (DbConfiguration) data;
                     if (configuration.isOwnConfiguration()) {
                         configuration.updateConfiguration();
                     }
                     configuration.changeUpdatedInfo(AbstractDbData.UpdatedInfo.NOTUPDATED);
                         configuration.update();
                 }
                 // Check HostAuthent
                 else if (data instanceof DbHostAuth) {
                     DbHostAuth hostAuth = (DbHostAuth) data;
                     // Nothing to do except validate
                     hostAuth.changeUpdatedInfo(AbstractDbData.UpdatedInfo.NOTUPDATED);
                     hostAuth.update();
                 }
                 // Check Rules
                 else if (data instanceof DbRule) {
                     // Nothing to do except validate
                     DbRule rule = (DbRule) data;
                     rule.changeUpdatedInfo(AbstractDbData.UpdatedInfo.NOTUPDATED);
                     rule.update();
                 }
                 // Check TaskRunner
                 else if (data instanceof DbTaskRunner) {
                     DbTaskRunner taskRunner = (DbTaskRunner) data;
                     logger.debug("get a task: {}",taskRunner);
                     // Launch if possible this task
                     String key = taskRunner.getRequested()+" "+taskRunner.getRequester()+
                         " "+taskRunner.getSpecialId();
                     if (Configuration.configuration.getLocalTransaction().
                             getFromRequest(key) != null) {
                         // already running
                         continue;
                     }
                     if (taskRunner.isSelfRequested()) {
                         // cannot schedule a request where the host is the requested host
                         taskRunner.changeUpdatedInfo(UpdatedInfo.INTERRUPTED);
                         taskRunner.update();
                         continue;
                     }
                     taskRunner.changeUpdatedInfo(UpdatedInfo.RUNNING);
                     taskRunner.update();
                     internalRunner.submitTaskRunner(taskRunner);
                     try {
                         Thread.sleep(Configuration.RETRYINMS);
                     } catch (InterruptedException e) {
                     }
                     taskRunner = null;
                 }
                 if (OpenR66SignalHandler.isInShutdown()) {
                     // no more task to submit
                     return;
                 }
             } catch (GoldenGateDatabaseException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }
     }
 
 }