/**
 * 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.
 */

package org.apache.hadoop.fs.slive;

import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.nio.ByteBuffer;

/**
 * Class which reads in and verifies bytes that have been read in
 */
class DataVerifier {
  private static final int BYTES_PER_LONG = Constants.BYTES_PER_LONG;

  private int bufferSize;

  /**
   * The output from verification includes the number of chunks that were the
   * same as expected and the number of segments that were different than what
   * was expected and the number of total bytes read
   */
  static class VerifyOutput {
    private long same;
    private long different;
    private long read;
    private long readTime;

    VerifyOutput(long sameChunks, long differentChunks, long readBytes,
        long readTime) {
      this.same = sameChunks;
      this.different = differentChunks;
      this.read = readBytes;
      this.readTime = readTime;
    }

    long getReadTime() {
      return this.readTime;
    }

    long getBytesRead() {
      return this.read;
    }

    long getChunksSame() {
      return same;
    }

    long getChunksDifferent() {
      return different;
    }

    public String toString() {
      return "Bytes read = " + getBytesRead() + " same = " + getChunksSame()
          + " different = " + getChunksDifferent() + " in " + getReadTime()
          + " milliseconds";
    }

  }

  /**
   * Class used to hold the result of a read on a header
   */
  private static class ReadInfo {
    private long byteAm;
    private long hash;
    private long timeTaken;
    private long bytesRead;

    ReadInfo(long byteAm, long hash, long timeTaken, long bytesRead) {
      this.byteAm = byteAm;
      this.hash = hash;
      this.timeTaken = timeTaken;
      this.bytesRead = bytesRead;
    }

    long getByteAm() {
      return byteAm;
    }

    long getHashValue() {
      return hash;
    }

    long getTimeTaken() {
      return timeTaken;
    }

    long getBytesRead() {
      return bytesRead;
    }

  }

  /**
   * Storage class used to hold the chunks same and different for buffered reads
   * and the resultant verification
   */
  private static class VerifyInfo {

    VerifyInfo(long same, long different) {
      this.same = same;
      this.different = different;
    }

    long getSame() {
      return same;
    }

    long getDifferent() {
      return different;
    }

    private long same;
    private long different;
  }

  /**
   * Inits with given buffer size (must be greater than bytes per long and a
   * multiple of bytes per long)
   * 
   * @param bufferSize
   *          size which must be greater than BYTES_PER_LONG and which also must
   *          be a multiple of BYTES_PER_LONG
   */
  DataVerifier(int bufferSize) {
    if (bufferSize < BYTES_PER_LONG) {
      throw new IllegalArgumentException(
          "Buffer size must be greater than or equal to " + BYTES_PER_LONG);
    }
    if ((bufferSize % BYTES_PER_LONG) != 0) {
      throw new IllegalArgumentException("Buffer size must be a multiple of "
          + BYTES_PER_LONG);
    }
    this.bufferSize = bufferSize;
  }

  /**
   * Inits with the default buffer size
   */
  DataVerifier() {
    this(Constants.BUFFERSIZE);
  }

  /**
   * Verifies a buffer of a given size using the given start hash offset
   * 
   * @param buf
   *          the buffer to verify
   * @param size
   *          the number of bytes to be used in that buffer
   * @param startOffset
   *          the start hash offset
   * @param hasher
   *          the hasher to use for calculating expected values
   * 
   * @return ResumeBytes a set of data about the next offset and chunks analyzed
   */
  private VerifyInfo verifyBuffer(ByteBuffer buf, int size, long startOffset,
      DataHasher hasher) {
    ByteBuffer cmpBuf = ByteBuffer.wrap(new byte[BYTES_PER_LONG]);
    long hashOffset = startOffset;
    long chunksSame = 0;
    long chunksDifferent = 0;
    for (long i = 0; i < size; ++i) {
      cmpBuf.put(buf.get());
      if (!cmpBuf.hasRemaining()) {
        cmpBuf.rewind();
        long receivedData = cmpBuf.getLong();
        cmpBuf.rewind();
        long expected = hasher.generate(hashOffset);
        hashOffset += BYTES_PER_LONG;
        if (receivedData == expected) {
          ++chunksSame;
        } else {
          ++chunksDifferent;
        }
      }
    }
    // any left over??
    if (cmpBuf.hasRemaining() && cmpBuf.position() != 0) {
      // partial capture
      // zero fill and compare with zero filled
      int curSize = cmpBuf.position();
      while (cmpBuf.hasRemaining()) {
        cmpBuf.put((byte) 0);
      }
      long expected = hasher.generate(hashOffset);
      ByteBuffer tempBuf = ByteBuffer.wrap(new byte[BYTES_PER_LONG]);
      tempBuf.putLong(expected);
      tempBuf.position(curSize);
      while (tempBuf.hasRemaining()) {
        tempBuf.put((byte) 0);
      }
      cmpBuf.rewind();
      tempBuf.rewind();
      if (cmpBuf.equals(tempBuf)) {
        ++chunksSame;
      } else {
        ++chunksDifferent;
      }
    }
    return new VerifyInfo(chunksSame, chunksDifferent);
  }

  /**
   * Determines the offset to use given a byte counter
   * 
   * @param byteRead
   * 
   * @return offset position
   */
  private long determineOffset(long byteRead) {
    if (byteRead < 0) {
      byteRead = 0;
    }
    return (byteRead / BYTES_PER_LONG) * BYTES_PER_LONG;
  }

  /**
   * Verifies a given number of bytes from a file - less number of bytes may be
   * read if a header can not be read in due to the byte limit
   * 
   * @param byteAm
   *          the byte amount to limit to (should be less than or equal to file
   *          size)
   * 
   * @param in
   *          the input stream to read from
   * 
   * @return VerifyOutput with data about reads
   * 
   * @throws IOException
   *           if a read failure occurs
   * 
   * @throws BadFileException
   *           if a header can not be read or end of file is reached
   *           unexpectedly
   */
  VerifyOutput verifyFile(long byteAm, DataInputStream in)
      throws IOException, BadFileException {
    return verifyBytes(byteAm, 0, in);
  }

  /**
   * Verifies a given number of bytes from a file - less number of bytes may be
   * read if a header can not be read in due to the byte limit
   * 
   * @param byteAm
   *          the byte amount to limit to (should be less than or equal to file
   *          size)
   * 
   * @param bytesRead
   *          the starting byte location
   * 
   * @param in
   *          the input stream to read from
   * 
   * @return VerifyOutput with data about reads
   * 
   * @throws IOException
   *           if a read failure occurs
   * 
   * @throws BadFileException
   *           if a header can not be read or end of file is reached
   *           unexpectedly
   */
  private VerifyOutput verifyBytes(long byteAm, long bytesRead,
      DataInputStream in) throws IOException, BadFileException {
    if (byteAm <= 0) {
      return new VerifyOutput(0, 0, 0, 0);
    }
    long chunksSame = 0;
    long chunksDifferent = 0;
    long readTime = 0;
    long bytesLeft = byteAm;
    long bufLeft = 0;
    long bufRead = 0;
    long seqNum = 0;
    DataHasher hasher = null;
    ByteBuffer readBuf = ByteBuffer.wrap(new byte[bufferSize]);
    while (bytesLeft > 0) {
      if (bufLeft <= 0) {
        if (bytesLeft < DataWriter.getHeaderLength()) {
          // no bytes left to read a header
          break;
        }
        // time to read a new header
        ReadInfo header = null;
        try {
          header = readHeader(in);
        } catch (EOFException e) {
          // eof ok on header reads
          // but not on data readers
          break;
        }
        ++seqNum;
        hasher = new DataHasher(header.getHashValue());
        bufLeft = header.getByteAm();
        readTime += header.getTimeTaken();
        bytesRead += header.getBytesRead();
        bytesLeft -= header.getBytesRead();
        bufRead = 0;
        // number of bytes to read greater than how many we want to read
        if (bufLeft > bytesLeft) {
          bufLeft = bytesLeft;
        }
        // does the buffer amount have anything??
        if (bufLeft <= 0) {
          continue;
        }
      }
      // figure out the buffer size to read
      int bufSize = bufferSize;
      if (bytesLeft < bufSize) {
        bufSize = (int) bytesLeft;
      }
      if (bufLeft < bufSize) {
        bufSize = (int) bufLeft;
      }
      // read it in
      try {
        readBuf.rewind();
        long startTime = Timer.now();
        in.readFully(readBuf.array(), 0, bufSize);
        readTime += Timer.elapsed(startTime);
      } catch (EOFException e) {
        throw new BadFileException(
            "Could not read the number of expected data bytes " + bufSize
                + " due to unexpected end of file during sequence " + seqNum, e);
      }
      // update the counters
      bytesRead += bufSize;
      bytesLeft -= bufSize;
      bufLeft -= bufSize;
      // verify what we read
      readBuf.rewind();
      // figure out the expected hash offset start point
      long vOffset = determineOffset(bufRead);
      // now update for new position
      bufRead += bufSize;
      // verify
      VerifyInfo verifyRes = verifyBuffer(readBuf, bufSize, vOffset, hasher);
      // update the verification counters
      chunksSame += verifyRes.getSame();
      chunksDifferent += verifyRes.getDifferent();
    }
    return new VerifyOutput(chunksSame, chunksDifferent, bytesRead, readTime);
  }


  /**
   * Reads a header from the given input stream
   * 
   * @param in
   *          input stream to read from
   * 
   * @return ReadInfo
   * 
   * @throws IOException
   *           if a read error occurs or EOF occurs
   * 
   * @throws BadFileException
   *           if end of file occurs or the byte amount read is invalid
   */
  ReadInfo readHeader(DataInputStream in) throws IOException,
      BadFileException {
    int headerLen = DataWriter.getHeaderLength();
    ByteBuffer headerBuf = ByteBuffer.wrap(new byte[headerLen]);
    long elapsed = 0;
    {
      long startTime = Timer.now();
      in.readFully(headerBuf.array());
      elapsed += Timer.elapsed(startTime);
    }
    headerBuf.rewind();
    long hashValue = headerBuf.getLong();
    long byteAvailable = headerBuf.getLong();
    if (byteAvailable < 0) {
      throw new BadFileException("Invalid negative amount " + byteAvailable
          + " determined for header data amount");
    }
    return new ReadInfo(byteAvailable, hashValue, elapsed, headerLen);
  }
}