package org.apache.maven.plugin.linkcheck;
   
   /* ====================================================================
    *   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 org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.maven.plugin.linkcheck.validation.LinkValidationItem;
  import org.apache.maven.plugin.linkcheck.validation.LinkValidationResult;
  import org.apache.maven.plugin.linkcheck.validation.LinkValidatorManager;
  
  import java.io.File;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Set;
  
  /**
   * @author <a href="mailto:bwalding@apache.org">Ben Walding</a>
   * @author <a href="mailto:aheritier@apache.org">Arnaud Heritier</a>
   * @version $Id: FileToCheck.java 532339 2007-04-25 12:28:56Z ltheussl $
   */
  public final class FileToCheck
  {
      /**
       * Log for debug output
       */
      private static final Log LOG = LogFactory.getLog( FileToCheck.class );
  
      public static final String STATUS_UNKNOWN = null;
  
      public static final String STATUS_JTIDY_FAILURE = "Unable to tidy source";
  
      public static final String STATUS_OK = "OK";
  
      private String base;
  
      private File fileToCheck;
  
      private List links = new LinkedList();
  
      private String message = "";
  
      private String status = STATUS_OK;
  
      private int successful;
  
      private int unsuccessful;
  
      /**
       * Returns the message.
       * 
       * @return String
       */
      public String getMessage()
      {
          return this.message;
      }
  
      public String getName()
      {
          String fileName = this.fileToCheck.getAbsolutePath();
          if ( fileName.startsWith( this.base ) )
          {
              fileName = fileName.substring( this.base.length() + 1 );
          }
  
          fileName = fileName.replace( '\\', '/' );
          return fileName;
      }
  
      public List getResults()
      {
          return this.links;
      }
  
      /**
       * Returns the status.
       * 
       * @return int
       */
      public String getStatus()
      {
          return this.status;
     }
 
     /**
      * Returns the successful.
      * 
      * @return int
      */
     public int getSuccessful()
     {
         return this.successful;
     }
 
     /**
      * Returns the unsuccessful.
      * 
      * @return int
      */
     public int getUnsuccessful()
     {
         return this.unsuccessful;
     }
 
     public FileToCheck( File baseFile, File fileToCheck )
     {
         this.base = baseFile.getAbsolutePath();
         this.fileToCheck = fileToCheck;
     }
 
     public void check( LinkValidatorManager lvm ) throws Exception
     {
         this.successful = 0;
         this.unsuccessful = 0;
         this.status = STATUS_OK;
         this.message = "";
         if ( LOG.isDebugEnabled() )
         {
             LOG.debug( "Validating " + getName() );
         }
         try
         {
             final Set hrefs;
             try
             {
                 hrefs = LinkMatcher.match( this.fileToCheck );
             }
             catch ( Throwable t )
             {
                 // We catch Throwable, because there is a chance that the domReader will throw
                 // a stack overflow exception for some files
                 if ( LOG.isDebugEnabled() )
                 {
                     LOG.error( "Received: [" + t + "] in page [" + getName() + "]", t );
                 }
                 else
                 {
                     LOG.error( "Received: [" + t + "] in page [" + getName() + "]" );
                 }
                 LinkCheckResult lcr = new LinkCheckResult();
                 lcr.setStatus( "PARSE FAILURE" );
                 lcr.setTarget( "N/A" );
                 addResult( lcr );
                 return;
             }
             String href;
             LinkCheckResult lcr;
             LinkValidationItem lvi;
             LinkValidationResult result;
             for ( Iterator iter = hrefs.iterator(); iter.hasNext(); )
             {
                 href = (String) iter.next();
                 lcr = new LinkCheckResult();
                 lvi = new LinkValidationItem( this.fileToCheck, href );
                 result = lvm.validateLink( lvi );
                 lcr.setTarget( href );
                 lcr.setErrorMessage( result.getErrorMessage() );
                 switch ( result.getStatus() )
                 {
                     case LinkValidationResult.VALID:
                         this.successful++;
                         lcr.setStatus( "valid" );
                         addResult( lcr ); // At some point we won't want to store valid links. The tests require that
                         // we do at present
                         break;
                     case LinkValidationResult.UNKNOWN:
                         this.unsuccessful++;
                         lcr.setStatus( "unknown" );
                         addResult( lcr );
                         break;
                     case LinkValidationResult.ERROR:
                         this.unsuccessful++;
                         lcr.setStatus( "error" );
                         addResult( lcr );
                         break;
                     case LinkValidationResult.WARNING:
                         this.unsuccessful++;
                         lcr.setStatus( "warning" );
                         addResult( lcr );
                         break;
                 }
             }
             href = null;
             lcr = null;
             lvi = null;
             result = null;
 
         }
         catch ( Exception e )
         {
             LOG.error( this.message );
             throw e;
         }
     }
 
     public String toXML()
     {
         StringBuffer buf = new StringBuffer();
         buf.append( "  <file>\n" );
         buf.append( "    <name><![CDATA[" + getName() + "]]></name>\n" );
         buf.append( "    <successful>" + getSuccessful() + "</successful>\n" );
         buf.append( "    <unsuccessful>" + getUnsuccessful() + "</unsuccessful>\n" );
         Iterator iter = getResults().iterator();
         LinkCheckResult result;
         while ( iter.hasNext() )
         {
             result = (LinkCheckResult) iter.next();
             buf.append( result.toXML() );
         }
         buf.append( "  </file>\n" );
         return buf.toString();
     }
 
     private void addResult( LinkCheckResult lcr )
     {
         this.links.add( lcr );
     }
 }