/*
    * Copyright 1999-2002,2004 The Apache Software Foundation.
    * 
    * Licensed 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.
   */
  
  package org.apache.commons.latka.validators;
  
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileReader;
  import java.io.InputStream;
  import java.io.IOException;
  
  import java.util.StringTokenizer;
  
  import org.apache.commons.latka.Validator;
  import org.apache.commons.latka.ValidationException;
  import org.apache.commons.latka.http.Response;
  
  /** Compare the response with a golden
      file.  Right now this is a proof
      of concept class; we should extend it to support
      more than just files, I think.  Also, maybe
      golden files should be more than just text.
  */
  public class GoldenFileValidator extends BaseValidator 
  implements Validator {
  
      protected File _goldFile = null;
      protected boolean _ignoreWhitespace=false;
      protected static String TRUE_MESSAGE = "EXPECTED TO MATCH GOLDEN FILE: ";
      protected StringBuffer _matchLog = new StringBuffer();
  
      public GoldenFileValidator(File goldenFile) {
          this(null,goldenFile);
      }
  
      public GoldenFileValidator(String label, File goldenFile) {
          super(label);
          _goldFile = goldenFile;
      }
  
      public void setIgnoreWhitespace(boolean ignoreWhitespace) {
          _ignoreWhitespace = ignoreWhitespace;
      }
  
      public void validate(Response response)
      throws ValidationException {
  
          // Compare the results and set the status
          boolean cmp=true;
  
          if (_ignoreWhitespace) {
              String goldFileString = null;
  
              try {
                  FileReader reader = new FileReader(_goldFile);
  
                  StringBuffer buf = new StringBuffer();
  
                  while (true) {
                      int ch = reader.read();
                      if (ch < 0) {
                          break;
                      }
                      buf.append((char) ch);
                  }
  
                  goldFileString = buf.toString();
              } catch (IOException e) {
                  fail(e.toString());
              }
  
              cmp=compareWeak(response.getResource(), goldFileString );
          } else {
              try {
                  InputStream responseStream = response.getStream();
                  ByteArrayOutputStream responseBytes = new ByteArrayOutputStream();
                  while (true) {
                      int ch = responseStream.read();
                      if (ch < 0) {
                          break;
                      }
                      responseBytes.write(ch);
                  }
  
                  FileInputStream fileStream = new FileInputStream(_goldFile);
                 ByteArrayOutputStream fileBytes = new ByteArrayOutputStream();
                 while (true) {
                     int ch = fileStream.read();
                     if (ch < 0) {
                         break;
                     }
                     fileBytes.write(ch);
                 }
 
                 cmp=compare(new String(responseBytes.toByteArray()).getBytes(), 
                             new String(fileBytes.toByteArray()).getBytes() );
             } catch (IOException e) {
                 fail(e.toString());
             }
         }
 
         if (cmp == false) {
             StringBuffer buf = new StringBuffer();
             buf.append(TRUE_MESSAGE);
             buf.append(_goldFile);
             buf.append("\n");
             buf.append(_matchLog);
             fail(buf.toString());
         }
 
 
     }
 
     // Compare the actual result and the expected result.
     protected boolean compare(byte[] array1, byte[] array2) {
         if ( array1==null || array2==null) return false;
         if ( array1.length != array2.length ) {
             log("Wrong size " + array1.length + " " + array2.length );
             log("char 1:" + array1[array2.length - 1]);
             log("char 2:" + array2[array2.length - 1]);
             return false;
         }
 
         for (int i=0; i<array1.length ; i++ ) {
             if (array1[i] != array2[i] ) {
                 log("Error at " + i  + "comparing '" + array1[i] +
                     "' to '" + array2[i] + "'");
                 return false;
             }
         }
         return true;
     }
 
     // Compare the actual result and the expected result.
     // Original compare - ignores whitespace ( because most
     // golden files are wrong !)
     protected boolean compareWeak(String str1, String str2) {
         if ( str1==null || str2==null) return false;
 
         StringTokenizer st1=new StringTokenizer(str1);
         StringTokenizer st2=new StringTokenizer(str2);
 
         while (st1.hasMoreTokens() && st2.hasMoreTokens()) {
             String tok1 = st1.nextToken();
             String tok2 = st2.nextToken();
             if (!tok1.equals(tok2)) {
                 log("\tFAIL*** : Live token = " + tok1 
                     + ", did not match golden file token = " + tok2);
                 return false;
             }
         }
 
         if (st1.hasMoreTokens() || st2.hasMoreTokens()) {
             return false;
         } else {
             return true;
         }
     }
 
     protected void log(String message) {
         _matchLog.append(message);
     }
 
 }