/*
    * 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.commons.rng.core.source64;
  
  import java.util.Arrays;
  
  import org.apache.commons.rng.JumpableUniformRandomProvider;
  import org.apache.commons.rng.LongJumpableUniformRandomProvider;
  import org.apache.commons.rng.UniformRandomProvider;
  import org.apache.commons.rng.core.util.NumberFactory;
  
  /**
   * This abstract class is a base for algorithms from the Xor-Shift-Rotate family of 64-bit
   * generators with 1024-bits of state.
   *
   * @see <a href="http://xoshiro.di.unimi.it/">xorshiro / xoroshiro generators</a>
   * @since 1.3
   */
  abstract class AbstractXoRoShiRo1024 extends LongProvider implements LongJumpableUniformRandomProvider {
      /** Size of the state vector. */
      private static final int SEED_SIZE = 16;
      /** The coefficients for the jump function. */
      private static final long[] JUMP_COEFFICIENTS = {
          0x931197d8e3177f17L, 0xb59422e0b9138c5fL, 0xf06a6afb49d668bbL, 0xacb8a6412c8a1401L,
          0x12304ec85f0b3468L, 0xb7dfe7079209891eL, 0x405b7eec77d9eb14L, 0x34ead68280c44e4aL,
          0xe0e4ba3e0ac9e366L, 0x8f46eda8348905b7L, 0x328bf4dbad90d6ffL, 0xc8fd6fb31c9effc3L,
          0xe899d452d4b67652L, 0x45f387286ade3205L, 0x03864f454a8920bdL, 0xa68fa28725b1b384L,
      };
      /** The coefficients for the long jump function. */
      private static final long[] LONG_JUMP_COEFFICIENTS = {
          0x7374156360bbf00fL, 0x4630c2efa3b3c1f6L, 0x6654183a892786b1L, 0x94f7bfcbfb0f1661L,
          0x27d8243d3d13eb2dL, 0x9701730f3dfb300fL, 0x2f293baae6f604adL, 0xa661831cb60cd8b6L,
          0x68280c77d9fe008cL, 0x50554160f5ba9459L, 0x2fc20b17ec7b2a9aL, 0x49189bbdc8ec9f8fL,
          0x92a65bca41852cc1L, 0xf46820dd0509c12aL, 0x52b00c35fbf92185L, 0x1e5b3b7f589e03c1L,
      };
      /** State. */
      private final long[] state = new long[SEED_SIZE];
      /** Index in "state" array. */
      private int index;
  
      /**
       * Creates a new instance.
       *
       * @param seed Initial seed.
       * If the length is larger than 16, only the first 16 elements will
       * be used; if smaller, the remaining elements will be automatically
       * set. A seed containing all zeros will create a non-functional generator.
       */
      AbstractXoRoShiRo1024(long[] seed) {
          setSeedInternal(seed);
      }
  
      /**
       * Creates a copy instance.
       *
       * @param source Source to copy.
       */
      protected AbstractXoRoShiRo1024(AbstractXoRoShiRo1024 source) {
          super(source);
          System.arraycopy(source.state, 0, state, 0, SEED_SIZE);
          index = source.index;
      }
  
      /** {@inheritDoc} */
      @Override
      protected byte[] getStateInternal() {
          final long[] s = Arrays.copyOf(state, SEED_SIZE + 1);
          s[SEED_SIZE] = index;
  
          return composeStateInternal(NumberFactory.makeByteArray(s),
                                      super.getStateInternal());
      }
  
      /** {@inheritDoc} */
      @Override
      protected void setStateInternal(byte[] s) {
          final byte[][] c = splitStateInternal(s, (SEED_SIZE + 1) * 8);
  
          final long[] tmp = NumberFactory.makeLongArray(c[0]);
          System.arraycopy(tmp, 0, state, 0, SEED_SIZE);
          index = (int) tmp[SEED_SIZE];
  
          super.setStateInternal(c[1]);
      }
 
     /**
      * Seeds the RNG.
      *
      * @param seed Seed.
      */
     private void setSeedInternal(long[] seed) {
         // Reset the whole state of this RNG (i.e. "state" and "index").
         // Filling procedure is not part of the reference code.
         fillState(state, seed);
         index = 0;
     }
 
     /** {@inheritDoc} */
     @Override
     public long next() {
         final int q = index;
         index = (index + 1) & 15;
         final long s0 = state[index];
         long s15 = state[q];
         final long result = transform(s0, s15);
 
         s15 ^= s0;
         state[q] = Long.rotateLeft(s0, 25) ^ s15 ^ (s15 << 27);
         state[index] = Long.rotateLeft(s15, 36);
 
         return result;
     }
 
     /**
      * Transform the two consecutive 64-bit states of the generator to a 64-bit output.
      * The transformation function shall vary with respect to different generators.
      *
      * @param s0 The current state.
      * @param s15 The previous state.
      * @return the output
      */
     protected abstract long transform(long s0, long s15);
 
     /**
      * {@inheritDoc}
      *
      * <p>The jump size is the equivalent of 2<sup>512</sup>
      * calls to {@link UniformRandomProvider#nextLong() nextLong()}. It can provide
      * up to 2<sup>512</sup> non-overlapping subsequences.</p>
      */
     @Override
     public UniformRandomProvider jump() {
         final UniformRandomProvider copy = copy();
         performJump(JUMP_COEFFICIENTS);
         return copy;
     }
 
     /**
      * {@inheritDoc}
      *
      *
      * <p>The jump size is the equivalent of 2<sup>768</sup> calls to
      * {@link UniformRandomProvider#nextLong() nextLong()}. It can provide up to
      * 2<sup>256</sup> non-overlapping subsequences of length 2<sup>768</sup>; each
      * subsequence can provide up to 2<sup>256</sup> non-overlapping subsequences of
      * length 2<sup>512</sup> using the {@link #jump()} method.</p>
      */
     @Override
     public JumpableUniformRandomProvider longJump() {
         final JumpableUniformRandomProvider copy = copy();
         performJump(LONG_JUMP_COEFFICIENTS);
         return copy;
     }
 
     /**
      * Create a copy.
      *
      * @return the copy
      */
     protected abstract AbstractXoRoShiRo1024 copy();
 
     /**
      * Perform the jump to advance the generator state. Resets the cached state of the generator.
      *
      * @param jumpCoefficients the jump coefficients
      */
     private void performJump(long[] jumpCoefficients) {
         final long[] newState = new long[SEED_SIZE];
         for (final long jc : jumpCoefficients) {
             for (int b = 0; b < 64; b++) {
                 if ((jc & (1L << b)) != 0) {
                     for (int i = 0; i < SEED_SIZE; i++) {
                         newState[i] ^= state[(i + index) & 15];
                     }
                 }
                 next();
             }
         }
         // Note: Calling the next() function updates 'index'.
         // The present index effectively becomes 0.
         for (int j = 0; j < 16; j++) {
             state[(j + index) & 15] = newState[j];
         }
         resetCachedState();
     }
 }