/*
    * This file is part of Waarp Project (named also Waarp or GG).
    *
    *  Copyright (c) 2019, Waarp SAS, and individual contributors by the @author
    *  tags. See the COPYRIGHT.txt in the distribution for a full listing of
    * individual contributors.
    *
    *  All Waarp Project is free software: you can redistribute it and/or
    * modify it under the terms of the GNU General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or (at your
   * option) any later version.
   *
   * Waarp is distributed in the hope that it will be useful, but WITHOUT ANY
   * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License along with
   * Waarp . If not, see <http://www.gnu.org/licenses/>.
   */
  
  /*
   * 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.waarp.compress.zstdsafe;
  
  import static org.waarp.compress.zstdsafe.Constants.*;
  import static org.waarp.compress.zstdsafe.UnsafeUtil.*;
  
  class SequenceStore {
    public final byte[] literalsBuffer;
    public int literalsLength;
  
    public final int[] offsets;
    public final int[] literalLengths;
    public final int[] matchLengths;
    public int sequenceCount;
  
    public final byte[] literalLengthCodes;
    public final byte[] matchLengthCodes;
    public final byte[] offsetCodes;
  
    public LongField longLengthField;
    public int longLengthPosition;
  
    public enum LongField {
      LITERAL, MATCH
    }
  
    private static final byte[] LITERAL_LENGTH_CODE = {
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 16, 17, 17, 18,
        18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22,
        22, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24,
        24, 24, 24, 24, 24, 24, 24
    };
  
    private static final byte[] MATCH_LENGTH_CODE = {
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
        21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32, 33, 33, 34, 34, 35,
        35, 36, 36, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38, 38, 38, 39,
        39, 39, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
        40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
        41, 41, 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
        42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42
    };
  
    public SequenceStore(final int blockSize, final int maxSequences) {
      offsets = new int[maxSequences];
      literalLengths = new int[maxSequences];
      matchLengths = new int[maxSequences];
  
      literalLengthCodes = new byte[maxSequences];
      matchLengthCodes = new byte[maxSequences];
      offsetCodes = new byte[maxSequences];
  
      literalsBuffer = new byte[blockSize];
  
      reset();
    }
  
    public void appendLiterals(final byte[] inputBase, final int inputAddress,
                               final int inputSize) {
      copyMemory(inputBase, inputAddress, literalsBuffer, literalsLength,
                 inputSize);
      literalsLength += inputSize;
    }
  
    public void storeSequence(final byte[] literalBase, final int literalAddress,
                              final int literalLength, final int offsetCode,
                              final int matchLengthBase) {
     int input = literalAddress;
     int output = literalsLength;
     int copied = 0;
     do {
       putLong(literalsBuffer, output, getLong(literalBase, input));
       input += SIZE_OF_LONG;
       output += SIZE_OF_LONG;
       copied += SIZE_OF_LONG;
     } while (copied < literalLength);
 
     literalsLength += literalLength;
 
     if (literalLength > 65535) {
       longLengthField = LongField.LITERAL;
       longLengthPosition = sequenceCount;
     }
     literalLengths[sequenceCount] = literalLength;
 
     offsets[sequenceCount] = offsetCode + 1;
 
     if (matchLengthBase > 65535) {
       longLengthField = LongField.MATCH;
       longLengthPosition = sequenceCount;
     }
 
     matchLengths[sequenceCount] = matchLengthBase;
 
     sequenceCount++;
   }
 
   public void reset() {
     literalsLength = 0;
     sequenceCount = 0;
     longLengthField = null;
   }
 
   public void generateCodes() {
     for (int i = 0; i < sequenceCount; ++i) {
       literalLengthCodes[i] = (byte) literalLengthToCode(literalLengths[i]);
       offsetCodes[i] = (byte) Util.highestBit(offsets[i]);
       matchLengthCodes[i] = (byte) matchLengthToCode(matchLengths[i]);
     }
 
     if (longLengthField == LongField.LITERAL) {
       literalLengthCodes[longLengthPosition] =
           Constants.MAX_LITERALS_LENGTH_SYMBOL;
     }
     if (longLengthField == LongField.MATCH) {
       matchLengthCodes[longLengthPosition] = Constants.MAX_MATCH_LENGTH_SYMBOL;
     }
   }
 
   private static int literalLengthToCode(final int literalLength) {
     if (literalLength >= 64) {
       return Util.highestBit(literalLength) + 19;
     } else {
       return LITERAL_LENGTH_CODE[literalLength];
     }
   }
 
   /*
    * matchLengthBase = matchLength - MINMATCH
    * (that's how it's stored in SequenceStore)
    */
   private static int matchLengthToCode(final int matchLengthBase) {
     if (matchLengthBase >= 128) {
       return Util.highestBit(matchLengthBase) + 36;
     } else {
       return MATCH_LENGTH_CODE[matchLengthBase];
     }
   }
 }