/*
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * 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.
 */
/*
 * Copyright owned by the Transaction Processing Performance Council.
 *
 * A copy of the license is included under extension/tpch/dbgen/LICENSE
 * in this repository.
 *
 * You may not use this file except in compliance with the License.
 *
 * THE TPC SOFTWARE IS AVAILABLE WITHOUT CHARGE FROM TPC.
 */
#include "dbgen/config.h" // @manual
#include "dbgen/dss.h" // @manual
#include "dbgen/rng64.h" // @manual

#include <stdio.h>
#include <stdlib.h>

namespace facebook::velox::tpch::dbgen {

/*  _tal long RandSeed = "Random^SeedFromTimestamp" (void); */

#define ADVANCE_STREAM(stream, num_calls) advanceStream(stream, num_calls, 0)
#define ADVANCE_STREAM64(stream, num_calls) advanceStream(stream, num_calls, 1)
#define MAX_COLOR 92
long name_bits[MAX_COLOR / BITS_PER_LONG];
void fakeVStr(int nAvg, long nSeed, DSS_HUGE nCount);
void NthElement(DSS_HUGE N, DSS_HUGE* StartSeed);

void advanceStream(seed_t* seed, DSS_HUGE nCalls, int bUse64Bit) {
  if (bUse64Bit)
    seed->value = AdvanceRand64(seed->value, nCalls);
  else
    NthElement(nCalls, &seed->value);

#ifdef RNG_TEST
  seed->nCalls += nCalls;
#endif

  return;
}

/* WARNING!  This routine assumes the existence of 64-bit                 */
/* integers.  The notation used here- "HUGE" is *not* ANSI standard. */
/* Hopefully, you have this extension as well.  If not, use whatever      */
/* nonstandard trick you need to in order to get 64 bit integers.         */
/* The book says that this will work if MAXINT for the type you choose    */
/* is at least 2**46  - 1, so 64 bits is more than you *really* need      */

static DSS_HUGE Multiplier = 16807; /* or whatever nonstandard */
static DSS_HUGE Modulus = 2147483647; /* trick you use to get 64 bit int */

/* Advances value of Seed after N applications of the random number generator
   with multiplier Mult and given Modulus.
   NthElement(Seed[],count);

   Theory:  We are using a generator of the form
        X_n = [Mult * X_(n-1)]  mod Modulus.    It turns out that
        X_n = [(Mult ** n) X_0] mod Modulus.
   This can be computed using a divide-and-conquer technique, see
   the code below.

   In words, this means that if you want the value of the Seed after n
   applications of the generator,  you multiply the initial value of the
   Seed by the "super multiplier" which is the basic multiplier raised
   to the nth power, and then take mod Modulus.
*/

/* Nth Element of sequence starting with StartSeed */
void NthElement(DSS_HUGE N, DSS_HUGE* StartSeed) {
  DSS_HUGE Z;
  DSS_HUGE Mult;
  static int ln = -1;

  if ((verbose > 0) && ++ln % 1000 == 0) {
    fprintf(stderr, "%c\b", lnoise[i]);
  }
  Mult = Multiplier;
  Z = static_cast<DSS_HUGE>(*StartSeed);
  while (N > 0) {
    if (N % 2 != 0) /* testing for oddness, this seems portable */
      Z = (Mult * Z) % Modulus;
    N = N / 2; /* integer division, truncates */
    Mult = (Mult * Mult) % Modulus;
  }
  *StartSeed = Z;

  return;
}

/* updates 'seed' using the tpch_a_rnd algorithm */
void fake_tpch_a_rnd(int min, int max, seed_t* seed) {
  DSS_HUGE len;
  DSS_HUGE itcount;

  RANDOM(len, min, max, seed);
  if (len % 5L == 0)
    itcount = len / 5;
  else
    itcount = len / 5 + 1L;
  NthElement(itcount, &seed->usage);
#ifdef RNG_TEST
  seed->nCalls += itcount;
#endif
  return;
}

long sd_part(int /*child*/, DSS_HUGE skip_count, DBGenContext* ctx) {
  int i;

  for (i = P_MFG_SD; i <= P_CNTR_SD; i++)
    ADVANCE_STREAM(&ctx->Seed[i], skip_count);

  ADVANCE_STREAM(&ctx->Seed[P_CMNT_SD], skip_count * 2);
  ADVANCE_STREAM(&ctx->Seed[P_NAME_SD], skip_count * 92);

  return (0L);
}

long sd_line(int child, DSS_HUGE skip_count, DBGenContext* ctx) {
  int i, j;

  for (j = 0; j < O_LCNT_MAX; j++) {
    for (i = L_QTY_SD; i <= L_RFLG_SD; i++)
      /*
                  if (ctx->scale_factor >= 30000 && i == L_PKEY_SD)
                      ADVANCE_STREAM64(&ctx->Seed[i], skip_count);
                  else
      */
      ADVANCE_STREAM(&ctx->Seed[i], skip_count);
    ADVANCE_STREAM(&ctx->Seed[L_CMNT_SD], skip_count * 2);
  }

  /* need to special case this as the link between master and detail */
  if (child == 1) {
    ADVANCE_STREAM(&ctx->Seed[O_ODATE_SD], skip_count);
    ADVANCE_STREAM(&ctx->Seed[O_LCNT_SD], skip_count);
  }

  return (0L);
}

long sd_order(int /*child*/, DSS_HUGE skip_count, DBGenContext* ctx) {
  ADVANCE_STREAM(&ctx->Seed[O_LCNT_SD], skip_count);
  /*
      if (ctx->scale_factor >= 30000)
          ADVANCE_STREAM64(&ctx->Seed[O_CKEY_SD], skip_count);
      else
  */
  ADVANCE_STREAM(&ctx->Seed[O_CKEY_SD], skip_count);
  ADVANCE_STREAM(&ctx->Seed[O_CMNT_SD], skip_count * 2);
  ADVANCE_STREAM(&ctx->Seed[O_SUPP_SD], skip_count);
  ADVANCE_STREAM(&ctx->Seed[O_CLRK_SD], skip_count);
  ADVANCE_STREAM(&ctx->Seed[O_PRIO_SD], skip_count);
  ADVANCE_STREAM(&ctx->Seed[O_ODATE_SD], skip_count);

  return (0L);
}

long sd_psupp(int /*child*/, DSS_HUGE skip_count, DBGenContext* ctx) {
  int j;

  for (j = 0; j < SUPP_PER_PART; j++) {
    ADVANCE_STREAM(&ctx->Seed[PS_QTY_SD], skip_count);
    ADVANCE_STREAM(&ctx->Seed[PS_SCST_SD], skip_count);
    ADVANCE_STREAM(&ctx->Seed[PS_CMNT_SD], skip_count * 2);
  }

  return (0L);
}

long sd_cust(int /*child*/, DSS_HUGE skip_count, DBGenContext* ctx) {
  ADVANCE_STREAM(&ctx->Seed[C_ADDR_SD], skip_count * 9);
  ADVANCE_STREAM(&ctx->Seed[C_CMNT_SD], skip_count * 2);
  ADVANCE_STREAM(&ctx->Seed[C_NTRG_SD], skip_count);
  ADVANCE_STREAM(&ctx->Seed[C_PHNE_SD], 3L * skip_count);
  ADVANCE_STREAM(&ctx->Seed[C_ABAL_SD], skip_count);
  ADVANCE_STREAM(&ctx->Seed[C_MSEG_SD], skip_count);
  return (0L);
}

long sd_supp(int /*child*/, DSS_HUGE skip_count, DBGenContext* ctx) {
  ADVANCE_STREAM(&ctx->Seed[S_NTRG_SD], skip_count);
  ADVANCE_STREAM(&ctx->Seed[S_PHNE_SD], 3L * skip_count);
  ADVANCE_STREAM(&ctx->Seed[S_ABAL_SD], skip_count);
  ADVANCE_STREAM(&ctx->Seed[S_ADDR_SD], skip_count * 9);
  ADVANCE_STREAM(&ctx->Seed[S_CMNT_SD], skip_count * 2);
  ADVANCE_STREAM(&ctx->Seed[BBB_CMNT_SD], skip_count);
  ADVANCE_STREAM(&ctx->Seed[BBB_JNK_SD], skip_count);
  ADVANCE_STREAM(&ctx->Seed[BBB_OFFSET_SD], skip_count);
  ADVANCE_STREAM(&ctx->Seed[BBB_TYPE_SD], skip_count); /* avoid one trudge */

  return (0L);
}

long sd_nation(int /*child*/, DSS_HUGE skip_count, DBGenContext* ctx) {
  ADVANCE_STREAM(&ctx->Seed[N_CMNT_SD], skip_count * 2);

  return (0L);
}

long sd_region(int /*child*/, DSS_HUGE skip_count, DBGenContext* ctx) {
  ADVANCE_STREAM(&ctx->Seed[R_CMNT_SD], skip_count * 2);

  return (0L);
}

} // namespace facebook::velox::tpch::dbgen
