package org.apache.maven.scm.provider.integrity;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import com.mks.api.Command;
  import com.mks.api.MultiValue;
  import com.mks.api.Option;
  import com.mks.api.response.APIException;
  import com.mks.api.response.Field;
  import com.mks.api.response.Response;
  import com.mks.api.response.WorkItem;
  import com.mks.api.response.WorkItemIterator;
  import com.mks.api.si.SIModelTypeName;
  
  import java.util.ArrayList;
  import java.util.Calendar;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Date;
  import java.util.Hashtable;
  import java.util.List;
  import java.util.NoSuchElementException;
  
  /**
   * This class represents a MKS Integrity Configuration Management Project
   * <br>Provides metadata information about a Project
   *
   * @author <a href="mailto:cletus@mks.com">Cletus D'Souza</a>
   * @since 1.6
   */
  public class Project
  {
      public static final String NORMAL_PROJECT = "Normal";
  
      public static final String VARIANT_PROJECT = "Variant";
  
      public static final String BUILD_PROJECT = "Build";
  
      private String projectName;
  
      private String projectType;
  
      private String projectRevision;
  
      private String fullConfigSyntax;
  
      private Date lastCheckpoint;
  
      private APISession api;
  
      // Create a custom comparator to compare project members
      public static final Comparator<Member> FILES_ORDER = new Comparator<Member>()
      {
          public int compare( Member cmm1, Member cmm2 )
          {
              return cmm1.getMemberName().compareToIgnoreCase( cmm2.getMemberName() );
          }
      };
  
      /**
       * Checks if the given value is a valid MKS Integrity Label.
       * <br>If it's invalid, this method throws an exception providing the reason as string.
       *
       * @param tagName The checkpoint label name
       */
      public static void validateTag( String tagName )
          throws Exception
      {
          if ( tagName == null || tagName.length() == 0 )
          {
              throw new Exception( "The checkpoint label string is empty!" );
          }
  
          char ch = tagName.charAt( 0 );
          if ( !( ( 'A' <= ch && ch <= 'Z' ) || ( 'a' <= ch && ch <= 'z' ) ) )
          {
              throw new Exception( "The checkpoint label must start with an alpha character!" );
          }
  
          for ( char invalid : "$,.:;/\\@".toCharArray() )
          {
              if ( tagName.indexOf( invalid ) >= 0 )
             {
                 throw new Exception(
                     "The checkpoint label may cannot contain one of the following characters: $ , . : ; / \\ @" );
             }
         }
     }
 
     /**
      * Creates an instance of an Integrity SCM Project
      *
      * @param api        MKS API Session object
      * @param configPath Configuration path for the MKS Integrity SCM Project
      * @throws APIException
      */
     public Project( APISession api, String configPath )
         throws APIException
     {
         // Initialize our local APISession
         this.api = api;
         try
         {
             // Get the project information for this project
             Command siProjectInfoCmd = new Command( Command.SI, "projectinfo" );
             siProjectInfoCmd.addOption( new Option( "project", configPath ) );
             api.getLogger().info( "Preparing to execute si projectinfo for " + configPath );
             Response infoRes = api.runCommand( siProjectInfoCmd );
             // Get the only work item from the response
             WorkItem wi = infoRes.getWorkItems().next();
             // Get the metadata information about the project
             Field pjNameFld = wi.getField( "projectName" );
             Field pjTypeFld = wi.getField( "projectType" );
             Field pjCfgPathFld = wi.getField( "fullConfigSyntax" );
             Field pjChkptFld = wi.getField( "lastCheckpoint" );
 
             // Convert to our class fields
             // First obtain the project name field
             if ( null != pjNameFld && null != pjNameFld.getValueAsString() )
             {
                 projectName = pjNameFld.getValueAsString();
             }
             else
             {
                 api.getLogger().warn( "Project info did not provide a value for the 'projectName' field!" );
                 projectName = "";
             }
             // Next, we'll need to know the project type
             if ( null != pjTypeFld && null != pjTypeFld.getValueAsString() )
             {
                 projectType = pjTypeFld.getValueAsString();
                 if ( isBuild() )
                 {
                     // Next, we'll need to know the current build checkpoint for this configuration
                     Field pjRevFld = wi.getField( "revision" );
                     if ( null != pjRevFld && null != pjRevFld.getItem() )
                     {
                         projectRevision = pjRevFld.getItem().getId();
                     }
                     else
                     {
                         projectRevision = "";
                         api.getLogger().warn( "Project info did not provide a vale for the 'revision' field!" );
                     }
                 }
             }
             else
             {
                 api.getLogger().warn( "Project info did not provide a value for the 'projectType' field!" );
                 projectType = "";
             }
             // Most important is the configuration path
             if ( null != pjCfgPathFld && null != pjCfgPathFld.getValueAsString() )
             {
                 fullConfigSyntax = pjCfgPathFld.getValueAsString();
             }
             else
             {
                 api.getLogger().error( "Project info did not provide a value for the 'fullConfigSyntax' field!" );
                 fullConfigSyntax = "";
             }
             // Finally, we'll need to store the last checkpoint to figure out differences, etc.
             if ( null != pjChkptFld && null != pjChkptFld.getDateTime() )
             {
                 lastCheckpoint = pjChkptFld.getDateTime();
             }
             else
             {
                 api.getLogger().warn( "Project info did not provide a value for the 'lastCheckpoint' field!" );
                 lastCheckpoint = Calendar.getInstance().getTime();
             }
         }
         catch ( NoSuchElementException nsee )
         {
             api.getLogger().error( "Project info did not provide a value for field " + nsee.getMessage() );
         }
     }
 
     /**
      * Returns the project path for this Integrity SCM Project
      *
      * @return
      */
     public String getProjectName()
     {
         return projectName;
     }
 
     /**
      * Returns the project revision for this Integrity SCM Project
      *
      * @return
      */
     public String getProjectRevision()
     {
         return projectRevision;
     }
 
     /**
      * Returns true is this is a Normal Project
      *
      * @return
      */
     public boolean isNormal()
     {
         return projectType.equalsIgnoreCase( NORMAL_PROJECT );
     }
 
     /**
      * Returns true if this is a Variant Project
      *
      * @return
      */
     public boolean isVariant()
     {
         return projectType.equalsIgnoreCase( VARIANT_PROJECT );
     }
 
     /**
      * Returns true if this is a Build Project
      *
      * @return
      */
     public boolean isBuild()
     {
         return projectType.equalsIgnoreCase( BUILD_PROJECT );
     }
 
     /**
      * Returns the Full Configuration Path for this Integrity SCM Project
      *
      * @return
      */
     public String getConfigurationPath()
     {
         return fullConfigSyntax;
     }
 
     /**
      * Returns the date when the last checkpoint was performed on this Project
      *
      * @return
      */
     public Date getLastCheckpointDate()
     {
         return lastCheckpoint;
     }
 
     /**
      * Parses the output from the si viewproject command to get a list of members
      *
      * @param workspaceDir The current workspace directory, which is required for an export
      * @return The list of Member objects for this project
      * @throws APIException
      */
     public List<Member> listFiles( String workspaceDir )
         throws APIException
     {
         // Re-initialize the member list for this project
         List<Member> memberList = new ArrayList<Member>();
         // Initialize the project config hash
         Hashtable<String, String> pjConfigHash = new Hashtable<String, String>();
         // Add the mapping for this project
         pjConfigHash.put( projectName, fullConfigSyntax );
         // Compute the project root directory
         String projectRoot = projectName.substring( 0, projectName.lastIndexOf( '/' ) );
 
         // Now, lets parse this project
         Command siViewProjectCmd = new Command( Command.SI, "viewproject" );
         siViewProjectCmd.addOption( new Option( "recurse" ) );
         siViewProjectCmd.addOption( new Option( "project", fullConfigSyntax ) );
         MultiValue mvFields = new MultiValue( "," );
         mvFields.add( "name" );
         mvFields.add( "context" );
         mvFields.add( "memberrev" );
         mvFields.add( "membertimestamp" );
         mvFields.add( "memberdescription" );
         siViewProjectCmd.addOption( new Option( "fields", mvFields ) );
         api.getLogger().info( "Preparing to execute si viewproject for " + fullConfigSyntax );
         Response viewRes = api.runCommand( siViewProjectCmd );
 
         // Iterate through the list of members returned by the API
         WorkItemIterator wit = viewRes.getWorkItems();
         while ( wit.hasNext() )
         {
             WorkItem wi = wit.next();
             if ( wi.getModelType().equals( SIModelTypeName.SI_SUBPROJECT ) )
             {
                 // Save the configuration path for the current subproject, using the canonical path name
                 pjConfigHash.put( wi.getField( "name" ).getValueAsString(), wi.getId() );
             }
             else if ( wi.getModelType().equals( SIModelTypeName.MEMBER ) )
             {
                 // Figure out this member's parent project's canonical path name
                 String parentProject = wi.getField( "parent" ).getValueAsString();
                 // Instantiate our Integrity CM Member object
                 Member iCMMember = new Member( wi, pjConfigHash.get( parentProject ), projectRoot, workspaceDir );
                 // Add this to the full list of members in this project
                 memberList.add( iCMMember );
             }
             else
             {
                 api.getLogger().warn( "View project output contains an invalid model type: " + wi.getModelType() );
             }
         }
 
         // Sort the files list...
         Collections.sort( memberList, FILES_ORDER );
         return memberList;
     }
 
     /**
      * Performs a checkpoint on the Integrity SCM Project
      *
      * @param message Checkpoint description
      * @param tag     Checkpoint label
      * @return MKS API Response object
      * @throws APIException
      */
     public Response checkpoint( String message, String tag )
         throws APIException
     {
         // Setup the checkpoint command
         api.getLogger().debug( "Checkpointing project " + fullConfigSyntax + " with label '" + tag + "'" );
         // Construct the checkpoint command
         Command siCheckpoint = new Command( Command.SI, "checkpoint" );
         siCheckpoint.addOption( new Option( "recurse" ) );
         // Set the project name
         siCheckpoint.addOption( new Option( "project", fullConfigSyntax ) );
         // Set the label
         siCheckpoint.addOption( new Option( "label", tag ) );
         // Set the description, if specified
         if ( null != message && message.length() > 0 )
         {
             siCheckpoint.addOption( new Option( "description", message ) );
         }
         // Run the checkpoint command
         return api.runCommand( siCheckpoint );
     }
 
     /**
      * Creates a Development Path (project branch) for the MKS Integrity SCM Project
      *
      * @param devPath Development Path Name
      * @return MKS API Response object
      * @throws APIException
      */
     public Response createDevPath( String devPath )
         throws APIException
     {
         // First we need to obtain a checkpoint from the current configuration (normal or variant)
         String chkpt = projectRevision;
         if ( !isBuild() )
         {
             Response chkptRes = checkpoint( "Pre-checkpoint for development path " + devPath, devPath + " Baseline" );
             WorkItem wi = chkptRes.getWorkItem( fullConfigSyntax );
             chkpt = wi.getResult().getField( "resultant" ).getItem().getId();
         }
 
         // Now lets setup the create development path command
         api.getLogger().debug(
             "Creating development path '" + devPath + "' for project " + projectName + " at revision '" + chkpt + "'" );
         Command siCreateDevPath = new Command( Command.SI, "createdevpath" );
         siCreateDevPath.addOption( new Option( "devpath", devPath ) );
         // Set the project name
         siCreateDevPath.addOption( new Option( "project", projectName ) );
         // Set the checkpoint we want to create the development path from
         siCreateDevPath.addOption( new Option( "projectRevision", chkpt ) );
         // Run the create development path command
         return api.runCommand( siCreateDevPath );
     }
 }