package customization.partlistener;

import java.io.Serializable;
import wt.services.StandardManager;
import wt.util.*;
import java.util.regex.*;
//##begin user.imports preserve=yes
import wt.events.KeyedEvent;
import wt.events.KeyedEventListener;
import wt.fc.Persistable;
import wt.fc.PersistenceManagerEvent;
import wt.part.*;
import wt.vc.*;
import wt.epm.*;
import wt.doc.*;
import java.util.*;
import wt.fc.PersistenceHelper;
import wt.fc.QueryResult;
import wt.lifecycle.State;
import wt.pds.StatementSpec;
import wt.query.QueryException;
import wt.query.QuerySpec;
import wt.query.SearchCondition;
import wt.services.ServiceEventListenerAdapter;
import wt.services.ManagerException;
import org.apache.log4j.Logger;
import wt.log4j.LogR;
//##end user.imports

//##begin StandardPartAuxService%37F382C802CE.doc preserve=no
/**
 *
 * <p>
 * Use the <code>newStandardPartAuxService</code> static factory method(s),
 * not the <code>StandardPartAuxService</code> constructor, to construct
 * instances of this class.  Instances must be constructed using the static
 * factory(s), in order to ensure proper initialization of the instance.
 * <p>
 *
 *
 * @version   1.0
 **/

//##end StandardPartAuxService%37F382C802CE.doc

public class StandardPartAuxService extends StandardManager implements PartAuxService, Serializable {

   // --- Attribute Section ---
   private static final String RESOURCE = "customization.partlistener.partauxResource";
   private static final String CLASSNAME = StandardPartAuxService.class.getName();

   //##begin user.attributes preserve=yes
   private PropertyResourceBundle props;
   //##end user.attributes
   
   //##begin static.initialization preserve=yes
   private KeyedEventListener listener;
   //##end static.initialization

   // --- Operation Section ---
   //##begin getConceptualClassname%getConceptualClassnameg.doc preserve=no
   /**
    * Returns the conceptual (modeled) name for the class.
    *
    * <BR><BR><B>Supported API: </B>true
    *
    * @return    String
    **/
   //##end getConceptualClassname%getConceptualClassnameg.doc
   private static Logger log=null;

    static
    {
        try
        {
            log = LogR.getLogger(StandardPartAuxService.class.getName());
        }
        catch(Exception e)
        {
        }
    }
    @Override

   public String getConceptualClassname() {
      //##begin getConceptualClassname%getConceptualClassnameg.body preserve=no
      return CLASSNAME;
      //##end getConceptualClassname%getConceptualClassnameg.body
   }

   //##begin newStandardPartAuxService%newStandardPartAuxServicef.doc preserve=no
   /**
    * Default factory for the class.
    *
    * @return    StandardPartAuxService
    * @exception wt.util.WTException
    **/
   //##end newStandardPartAuxService%newStandardPartAuxServicef.doc

   public static StandardPartAuxService newStandardPartAuxService()
            throws WTException {
      //##begin newStandardPartAuxService%newStandardPartAuxServicef.body preserve=no

      StandardPartAuxService instance = new StandardPartAuxService();
      instance.initialize();
      return instance;
      //##end newStandardPartAuxService%newStandardPartAuxServicef.body
   }

   //##begin user.operations preserve=yes
   /*
    * Internal Listener class
    */

   class PartAuxEventListener extends ServiceEventListenerAdapter {
      public PartAuxEventListener (String manager_name) {
         super (manager_name);
      }

      @Override
      public void notifyVetoableEvent (Object event)
         throws WTException {
         if (!(event instanceof KeyedEvent)) {
            return;
         }
         KeyedEvent keyedEvent = (KeyedEvent) event;
         Object target = keyedEvent.getEventTarget();
         if ( keyedEvent.getEventType( ).equals( PersistenceManagerEvent.POST_STORE ) ) {
             processEvent( (Persistable) target );
         }
      }
   }

   @Override
   protected void performStartupProcess( ) throws ManagerException {
      listener = new PartAuxEventListener( this.getConceptualClassname ( ) );
      try {
            props=(PropertyResourceBundle)PropertyResourceBundle.getBundle("customization.partlistener.VersionRules");
      }

      catch (MissingResourceException e)
      {
        e.printStackTrace();
        throw new ManagerException(e.getMessage());
      }
      getManagerService( ).addEventListener( listener, PersistenceManagerEvent.generateEventKey( PersistenceManagerEvent.POST_STORE) );
   }

   protected String getConfigNumber(String number)
    {
        //copied from DCC package.
        Pattern pattern = Pattern.compile(props.getString("goodrichPNRegEx"));
        if (pattern.matcher(number.toUpperCase()).matches())
        {
            pattern= Pattern.compile(props.getString("goodrichCNRegEx"));
            Matcher match = pattern.matcher(number);
            String config=null;
            while (match.find()) {
                config=match.group();
            }
            return config.substring(1);
        }
        else {
            return "";
        }
    }
   
      protected String getBaseNumber(String number)
    {
        //copied from DCC package.
        Pattern pattern = Pattern.compile(props.getString("goodrichPNRegEx"));
        if (pattern.matcher(number.toUpperCase()).matches())
        {
            pattern= Pattern.compile(props.getString("goodrichDNRegEx"));
            Matcher match = pattern.matcher(number);
            String base=null;
            while (match.find()) {
                base=match.group();
            }
            return base;
        }
        else {
            return "";
        }
    }

   protected void processEvent(Persistable target)
        throws WTException
    {
        log.debug("Processing Version Change Customization");
       //3-9-2009 - WTProduct nolonger exists.
        if (target instanceof WTPart) //&& !(target instanceof WTProduct))
        {
            WTPart part = (WTPart)target;
            if(part.getVersionIdentifier().getValue().equals("-"))
            {
                try
                {
                    String config = getConfigNumber(part.getNumber());
                    log.debug("Part Number:"+part.getNumber()+" - Config:"+ config );
                    int configNum = Integer.parseInt(config);
                    String baseNumber = getBaseNumber(part.getNumber());
                    log.debug("Base Number:"+baseNumber);
                    if (isBaseConfigNumBumpable(configNum))
                    {
                        log.debug("Case 1:Bump version due to matching config number.");
                        VersionControlHelper.service.changeRevision(part, "A", true);
                    }
                    else if (isDashConfigNumBumpable(configNum))
                    {
                        if (hasPreviousReleased001Drawing(baseNumber))
                        {
                            log.debug("Case 2:Bump version due to dash number.");
                            VersionControlHelper.service.changeRevision(part, "A", true);
                        }
                    }
                }
                catch(IndexOutOfBoundsException | NumberFormatException | WTException e) { }
            }
        } else
        if(target instanceof WTDocument)
        {
            WTDocument doc = (WTDocument)target;
            if(doc.getVersionIdentifier().getValue().equals("-"))
                try
                {
                    //String config = doc.getNumber().substring(doc.getNumber().length() - 4);
                    String config = getConfigNumber(doc.getNumber());
                    //Integer.parseInt(config);
                    int configNum = Integer.parseInt(config);
                    log.debug("Doc Number:"+doc.getNumber()+" - Config:"+ config );
                    String baseNumber = getBaseNumber(doc.getNumber());
                    log.debug("Base Number:"+baseNumber);
                    if (isBaseConfigNumBumpable(configNum))
                    {
                        log.debug("Case 1:Bump version due to matching config number.");
                        VersionControlHelper.service.changeRevision(doc, "A", true);
                    }
                    else if (isDashConfigNumBumpable(configNum))
                    {
                        if (hasPreviousReleased001Drawing(baseNumber))
                        {
                            log.debug("Case 2:Bump version due to dash number.");
                            VersionControlHelper.service.changeRevision(doc, "A", true);
                        }
                    }                    
                }
                catch(IndexOutOfBoundsException | NumberFormatException | WTException e) { }
        } else
        if(target instanceof EPMDocument)
        {
            EPMDocument doc = (EPMDocument)target;
            if(doc.getVersionIdentifier().getValue().equals("-"))
                try
                {
                    String config = getConfigNumber(doc.getNumber().substring(0,doc.getNumber().length() - 4));
                    int configNum = Integer.parseInt(config);
                    log.debug("Doc Number:"+doc.getNumber()+" - Config:"+ config );
                    String baseNumber = getBaseNumber(doc.getNumber());
                    log.debug("Base Number:"+baseNumber);
                    if (isBaseConfigNumBumpable(configNum))
                    {
                        log.debug("Case 1:Bump version due to matching config number.");
                        VersionControlHelper.service.changeRevision(doc, "A", true);
                    }
                    else if (isDashConfigNumBumpable(configNum))
                    {
                        if (hasPreviousReleased001Drawing(baseNumber))
                        {
                            log.debug("Case 2:Bump version due to dash number.");
                            VersionControlHelper.service.changeRevision(doc, "A", true);
                        }
                    } 
                }
                catch(IndexOutOfBoundsException | NumberFormatException | WTException e) { }
        }
    }
   
   //test if dash number config number should be bumped up or left alone
   protected boolean isDashConfigNumBumpable(int config)
   {
       return ((config > 199 && config < 900));
   }
   
   //test if config number should be bumped up or left alone
   protected boolean isBaseConfigNumBumpable(int config)
   {
       return ((config > 1 && config < 100));
   }
   
   protected boolean hasPreviousReleased001Drawing (String basenumber)
   {
       try {
           //search for previously released CAD drawing at 001 config
           log.debug("Testing if there is perviously released 001 drawing.");
           QuerySpec spec = new QuerySpec();    
           int epmDoc=spec.addClassList(EPMDocument.class,true);
           SearchCondition sc=new SearchCondition(EPMDocument.class,EPMDocument.LATEST_ITERATION,SearchCondition.IS_TRUE);
           spec.appendWhere(sc,new int[] {epmDoc});
           spec.appendAnd();
           sc=new SearchCondition(EPMDocument.class,EPMDocument.NUMBER,SearchCondition.LIKE,basenumber.toUpperCase()+"-001%");
           spec.appendWhere(sc,new int[] {epmDoc});
           log.debug("Searching for EPMDocument " + basenumber.toUpperCase()+"-001%");
           QueryResult result=PersistenceHelper.manager.find((StatementSpec)spec);
           log.debug(result.size() + " returns.");
           while (result.hasMoreElements())
           {
               Persistable[] pers=(Persistable[])result.nextElement();
               EPMDocument tempDoc=(EPMDocument)pers[0];
               String docType=tempDoc.getDocType().getStringValue();
               log.debug("Found " + tempDoc.getNumber());
               log.debug("State " +tempDoc.getState());
               log.debug("Doc Type " + docType);
               if(docType.equals("wt.epm.EPMDocumentType.CADDRAWING"))
                if (tempDoc.getState().getState().equals(State.toState("RELEASED")))
                {
                   log.debug("Found a CAD drawing released at 001 config.");
                   return true;
                }
           }
           //secondary search for released document drawing at 001 config
           spec = new QuerySpec();    
           epmDoc=spec.addClassList(WTDocument.class,true);
           sc=new SearchCondition(WTDocument.class,WTDocument.LATEST_ITERATION,SearchCondition.IS_TRUE);
           spec.appendWhere(sc,new int[] {epmDoc});
           spec.appendAnd();
           sc=new SearchCondition(WTDocument.class,WTDocument.NUMBER,SearchCondition.LIKE,basenumber.toUpperCase()+"-001");
           spec.appendWhere(sc,new int[] {epmDoc});
           log.debug("Searching for WTDocument " + basenumber.toUpperCase()+"-001%");
           result=PersistenceHelper.manager.find((StatementSpec)spec);
           log.debug(result.size() + " returns.");
           while (result.hasMoreElements())
           {
               Persistable[] pers=(Persistable[])result.nextElement();
               WTDocument tempDoc2=(WTDocument)pers[0];
               if ((tempDoc2.getState().getState().equals(State.toState("RELEASED"))))
               {
                log.debug("Found a Doc drawing released at 001 config.");   
                return true;
               }
           }
           return false;
       } 
       catch (QueryException ex) {
        }
       catch (WTException e){
        }
       return false;
       
   }
   //##end user.operations
}