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

import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.Collections;
import org.apache.hadoop.hbase.client.Durability;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.regionserver.Region;
import org.apache.hadoop.hbase.regionserver.RegionAsTable;
import org.apache.hadoop.hbase.util.Bytes;

/**
 * Similar to {@link HConstants} but for tests. Also provides some simple static utility functions
 * to generate test data.
 */
public class HTestConst {

  private HTestConst() {
  }

  public static final String DEFAULT_TABLE_STR = "MyTestTable";
  public static final byte[] DEFAULT_TABLE_BYTES = Bytes.toBytes(DEFAULT_TABLE_STR);
  public static final TableName DEFAULT_TABLE = TableName.valueOf(DEFAULT_TABLE_BYTES);

  public static final String DEFAULT_CF_STR = "MyDefaultCF";
  public static final byte[] DEFAULT_CF_BYTES = Bytes.toBytes(DEFAULT_CF_STR);

  public static final Set<String> DEFAULT_CF_STR_SET =
    Collections.unmodifiableSet(new HashSet<>(Arrays.asList(new String[] { DEFAULT_CF_STR })));

  public static final String DEFAULT_ROW_STR = "MyTestRow";
  public static final byte[] DEFAULT_ROW_BYTES = Bytes.toBytes(DEFAULT_ROW_STR);

  public static final String DEFAULT_QUALIFIER_STR = "MyColumnQualifier";
  public static final byte[] DEFAULT_QUALIFIER_BYTES = Bytes.toBytes(DEFAULT_QUALIFIER_STR);

  public static String DEFAULT_VALUE_STR = "MyTestValue";
  public static byte[] DEFAULT_VALUE_BYTES = Bytes.toBytes(DEFAULT_VALUE_STR);

  private static final char FIRST_CHAR = 'a';
  private static final char LAST_CHAR = 'z';
  private static final byte[] START_KEY_BYTES = { FIRST_CHAR, FIRST_CHAR, FIRST_CHAR };

  /**
   * Generate the given number of unique byte sequences by appending numeric suffixes (ASCII
   * representations of decimal numbers).
   */
  public static byte[][] makeNAscii(byte[] base, int n) {
    byte[][] ret = new byte[n][];
    for (int i = 0; i < n; i++) {
      byte[] tail = Bytes.toBytes(Integer.toString(i));
      ret[i] = Bytes.add(base, tail);
    }
    return ret;
  }

  /**
   * Add content to region <code>r</code> on the passed column <code>column</code>. Adds data of the
   * from 'aaa', 'aab', etc where key and value are the same.
   * @return count of what we added.
   */
  public static long addContent(final Region r, final byte[] columnFamily, final byte[] column)
    throws IOException {
    byte[] startKey = r.getRegionInfo().getStartKey();
    byte[] endKey = r.getRegionInfo().getEndKey();
    byte[] startKeyBytes = startKey;
    if (startKeyBytes == null || startKeyBytes.length == 0) {
      startKeyBytes = START_KEY_BYTES;
    }
    return addContent(new RegionAsTable(r), Bytes.toString(columnFamily), Bytes.toString(column),
      startKeyBytes, endKey, -1);
  }

  public static long addContent(final Region r, final byte[] columnFamily) throws IOException {
    return addContent(r, columnFamily, null);
  }

  /**
   * Add content to region <code>r</code> on the passed column <code>column</code>. Adds data of the
   * from 'aaa', 'aab', etc where key and value are the same.
   * @return count of what we added.
   */
  public static long addContent(Table updater, String columnFamily) throws IOException {
    return addContent(updater, columnFamily, START_KEY_BYTES, null);
  }

  public static long addContent(Table updater, String family, String column) throws IOException {
    return addContent(updater, family, column, START_KEY_BYTES, null);
  }

  /**
   * Add content to region <code>r</code> on the passed column <code>column</code>. Adds data of the
   * from 'aaa', 'aab', etc where key and value are the same.
   * @return count of what we added.
   */
  public static long addContent(Table updater, String columnFamily, byte[] startKeyBytes,
    byte[] endKey) throws IOException {
    return addContent(updater, columnFamily, null, startKeyBytes, endKey, -1);
  }

  public static long addContent(Table updater, String family, String column, byte[] startKeyBytes,
    byte[] endKey) throws IOException {
    return addContent(updater, family, column, startKeyBytes, endKey, -1);
  }

  /**
   * Add content to region <code>r</code> on the passed column <code>column</code>. Adds data of the
   * from 'aaa', 'aab', etc where key and value are the same.
   * @return count of what we added.
   */
  public static long addContent(Table updater, String columnFamily, String column,
    byte[] startKeyBytes, byte[] endKey, long ts) throws IOException {
    long count = 0;
    // Add rows of three characters. The first character starts with the
    // 'a' character and runs up to 'z'. Per first character, we run the
    // second character over same range. And same for the third so rows
    // (and values) look like this: 'aaa', 'aab', 'aac', etc.
    char secondCharStart = (char) startKeyBytes[1];
    char thirdCharStart = (char) startKeyBytes[2];
    EXIT: for (char c = (char) startKeyBytes[0]; c <= LAST_CHAR; c++) {
      for (char d = secondCharStart; d <= LAST_CHAR; d++) {
        for (char e = thirdCharStart; e <= LAST_CHAR; e++) {
          byte[] t = new byte[] { (byte) c, (byte) d, (byte) e };
          if (endKey != null && endKey.length > 0 && Bytes.compareTo(endKey, t) <= 0) {
            break EXIT;
          }
          Put put;
          if (ts != -1) {
            put = new Put(t, ts);
          } else {
            put = new Put(t);
          }
          StringBuilder sb = new StringBuilder();
          if (column != null && column.contains(":")) {
            sb.append(column);
          } else {
            if (columnFamily != null) {
              sb.append(columnFamily);
              if (!columnFamily.endsWith(":")) {
                sb.append(":");
              }
              if (column != null) {
                sb.append(column);
              }
            }
          }
          byte[][] split = CellUtil.parseColumn(Bytes.toBytes(sb.toString()));
          if (split.length == 1) {
            byte[] qualifier = new byte[0];
            put.addColumn(split[0], qualifier, t);
          } else {
            put.addColumn(split[0], split[1], t);
          }
          put.setDurability(Durability.SKIP_WAL);
          updater.put(put);
          count++;
        }
        // Set start character back to FIRST_CHAR after we've done first loop.
        thirdCharStart = FIRST_CHAR;
      }
      secondCharStart = FIRST_CHAR;
    }
    return count;
  }
}