// Copyright (c) 2017-2020, The rav1e contributors. All rights reserved
//
// This source code is subject to the terms of the BSD 2 Clause License and
// the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
// was not distributed with this source code in the LICENSE file, you can
// obtain it at www.aomedia.org/license/software. If the Alliance for Open
// Media Patent License 1.0 was not distributed with this source code in the
// PATENTS file, you can obtain it at www.aomedia.org/license/patent.

#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(dead_code)]

use crate::context::*;
use crate::partition::BlockSize::*;
use crate::partition::*;
use crate::transform::*;

static has_null: &[u8] = &[];

// Tables to store if the top-right reference pixels are available. The flags
// are represented with bits, packed into 8-bit integers. E.g., for the 32x32
// blocks in a 128x128 superblock, the index of the "o" block is 10 (in raster
// order), so its flag is stored at the 3rd bit of the 2nd entry in the table,
// i.e. (table[10 / 8] >> (10 % 8)) & 1.
//       . . . .
//       . . . .
//       . . o .
//       . . . .
#[rustfmt::skip]
static has_tr_4x4: &[u8] = &[
  255, 255, 255, 255, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85,
  127, 127, 127, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85,
  255, 127, 255, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85,
  127, 127, 127, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85,
  255, 255, 255, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85,
  127, 127, 127, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85,
  255, 127, 255, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85,
  127, 127, 127, 127, 85, 85, 85, 85, 119, 119, 119, 119, 85, 85, 85, 85,
];

static has_tr_4x8: &[u8] = &[
  255, 255, 255, 255, 119, 119, 119, 119, 127, 127, 127, 127, 119, 119, 119,
  119, 255, 127, 255, 127, 119, 119, 119, 119, 127, 127, 127, 127, 119, 119,
  119, 119, 255, 255, 255, 127, 119, 119, 119, 119, 127, 127, 127, 127, 119,
  119, 119, 119, 255, 127, 255, 127, 119, 119, 119, 119, 127, 127, 127, 127,
  119, 119, 119, 119,
];

#[rustfmt::skip]
static has_tr_8x4: &[u8] = &[
  255, 255, 0, 0, 85, 85, 0, 0, 119, 119, 0, 0, 85, 85, 0, 0,
  127, 127, 0, 0, 85, 85, 0, 0, 119, 119, 0, 0, 85, 85, 0, 0,
  255, 127, 0, 0, 85, 85, 0, 0, 119, 119, 0, 0, 85, 85, 0, 0,
  127, 127, 0, 0, 85, 85, 0, 0, 119, 119, 0, 0, 85, 85, 0, 0,
];

#[rustfmt::skip]
static has_tr_8x8: &[u8] = &[
  255, 255, 85, 85, 119, 119, 85, 85, 127, 127, 85, 85, 119, 119, 85, 85,
  255, 127, 85, 85, 119, 119, 85, 85, 127, 127, 85, 85, 119, 119, 85, 85,
];
static has_tr_8x16: &[u8] = &[
  255, 255, 119, 119, 127, 127, 119, 119, 255, 127, 119, 119, 127, 127, 119,
  119,
];
static has_tr_16x8: &[u8] =
  &[255, 0, 85, 0, 119, 0, 85, 0, 127, 0, 85, 0, 119, 0, 85, 0];
static has_tr_16x16: &[u8] = &[255, 85, 119, 85, 127, 85, 119, 85];
static has_tr_16x32: &[u8] = &[255, 119, 127, 119];
static has_tr_32x16: &[u8] = &[15, 5, 7, 5];
static has_tr_32x32: &[u8] = &[95, 87];
static has_tr_32x64: &[u8] = &[127];
static has_tr_64x32: &[u8] = &[19];
static has_tr_64x64: &[u8] = &[7];
static has_tr_64x128: &[u8] = &[3];
static has_tr_128x64: &[u8] = &[1];
static has_tr_128x128: &[u8] = &[1];
static has_tr_4x16: &[u8] = &[
  255, 255, 255, 255, 127, 127, 127, 127, 255, 127, 255, 127, 127, 127, 127,
  127, 255, 255, 255, 127, 127, 127, 127, 127, 255, 127, 255, 127, 127, 127,
  127, 127,
];
static has_tr_16x4: &[u8] = &[
  255, 0, 0, 0, 85, 0, 0, 0, 119, 0, 0, 0, 85, 0, 0, 0, 127, 0, 0, 0, 85, 0,
  0, 0, 119, 0, 0, 0, 85, 0, 0, 0,
];
static has_tr_8x32: &[u8] = &[255, 255, 127, 127, 255, 127, 127, 127];
static has_tr_32x8: &[u8] = &[15, 0, 5, 0, 7, 0, 5, 0];
static has_tr_16x64: &[u8] = &[255, 127];
static has_tr_64x16: &[u8] = &[3, 1];

static has_tr_tables: &[&[u8]] = &[
  has_tr_4x4,     // 4x4
  has_tr_4x8,     // 4x8
  has_tr_8x4,     // 8x4
  has_tr_8x8,     // 8x8
  has_tr_8x16,    // 8x16
  has_tr_16x8,    // 16x8
  has_tr_16x16,   // 16x16
  has_tr_16x32,   // 16x32
  has_tr_32x16,   // 32x16
  has_tr_32x32,   // 32x32
  has_tr_32x64,   // 32x64
  has_tr_64x32,   // 64x32
  has_tr_64x64,   // 64x64
  has_tr_64x128,  // 64x128
  has_tr_128x64,  // 128x64
  has_tr_128x128, // 128x128
  has_tr_4x16,    // 4x16
  has_tr_16x4,    // 16x4
  has_tr_8x32,    // 8x32
  has_tr_32x8,    // 32x8
  has_tr_16x64,   // 16x64
  has_tr_64x16,   // 64x16
];

#[rustfmt::skip]
static has_tr_vert_8x8: &[u8] = &[
  255, 255, 0, 0, 119, 119, 0, 0, 127, 127, 0, 0, 119, 119, 0, 0,
  255, 127, 0, 0, 119, 119, 0, 0, 127, 127, 0, 0, 119, 119, 0, 0,
];
static has_tr_vert_16x16: &[u8] = &[255, 0, 119, 0, 127, 0, 119, 0];
static has_tr_vert_32x32: &[u8] = &[15, 7];
static has_tr_vert_64x64: &[u8] = &[3];

// The _vert_* tables are like the ordinary tables above, but describe the
// order we visit square blocks when doing a PARTITION_VERT_A or
// PARTITION_VERT_B. This is the same order as normal except for on the last
// split where we go vertically (TL, BL, TR, BR). We treat the rectangular block
// as a pair of squares, which means that these tables work correctly for both
// mixed vertical partition types.
//
// There are tables for each of the square sizes. Vertical rectangles (like
// BLOCK_16X32) use their respective "non-vert" table
static has_tr_vert_tables: &[&[u8]] = &[
  has_null,          // 4X4
  has_tr_4x8,        // 4X8
  has_null,          // 8X4
  has_tr_vert_8x8,   // 8X8
  has_tr_8x16,       // 8X16
  has_null,          // 16X8
  has_tr_vert_16x16, // 16X16
  has_tr_16x32,      // 16X32
  has_null,          // 32X16
  has_tr_vert_32x32, // 32X32
  has_tr_32x64,      // 32X64
  has_null,          // 64X32
  has_tr_vert_64x64, // 64X64
  has_tr_64x128,     // 64x128
  has_null,          // 128x64
  has_tr_128x128,    // 128x128
];

// TODO: Enable the case for PARTITION_VERT_A/B once they can be encoded by rav1e.
pub fn get_has_tr_table(
  /*partition: PartitionType, */ bsize: BlockSize,
) -> &'static [u8] {
  let ret: &[u8];
  // If this is a mixed vertical partition, look up bsize in orders_vert.
  /*if partition == PartitionType::PARTITION_VERT_A || partition == PartitionType::PARTITION_VERT_B {
    debug_assert!(bsize < BlockSize::BLOCK_SIZES);
    ret = has_tr_vert_tables[bsize as usize];
  } else */
  {
    ret = has_tr_tables[bsize as usize];
  }

  //debug_assert!(ret != ptr::has_null());

  ret
}

pub fn has_top_right(
  bsize: BlockSize, partition_bo: TileBlockOffset, top_available: bool,
  right_available: bool, tx_size: TxSize, row_off: usize, col_off: usize,
  ss_x: usize, _ss_y: usize,
) -> bool {
  if !top_available || !right_available {
    return false;
  };

  let bw_unit = bsize.width_mi();
  let plane_bw_unit = (bw_unit >> ss_x).max(1);
  let top_right_count_unit = tx_size.width_mi();

  let mi_col = partition_bo.0.x;
  let mi_row = partition_bo.0.y;

  if row_off > 0 {
    // Just need to check if enough pixels on the right.
    // 128x128 SB is not supported yet by rav1e
    if bsize.width() > BLOCK_64X64.width() {
      // Special case: For 128x128 blocks, the transform unit whose
      // top-right corner is at the center of the block does in fact have
      // pixels available at its top-right corner.
      if row_off == BLOCK_64X64.height_mi() >> _ss_y
        && col_off + top_right_count_unit == BLOCK_64X64.width_mi() >> ss_x
      {
        return false;
      }
      let plane_bw_unit_64 = BLOCK_64X64.width_mi() >> ss_x;
      let col_off_64 = col_off % plane_bw_unit_64;
      return col_off_64 + top_right_count_unit < plane_bw_unit_64;
    }
    col_off + top_right_count_unit < plane_bw_unit
  } else {
    // All top-right pixels are in the block above, which is already available.
    if col_off + top_right_count_unit < plane_bw_unit {
      return true;
    };

    let bw_in_mi_log2 = bsize.width_log2() - MI_SIZE_LOG2;
    let bh_in_mi_log2 = bsize.height_log2() - MI_SIZE_LOG2;
    let sb_mi_size: usize = 16; // 64x64
    let blk_row_in_sb = (mi_row & (sb_mi_size - 1)) >> bh_in_mi_log2;
    let blk_col_in_sb = (mi_col & (sb_mi_size - 1)) >> bw_in_mi_log2;

    // Top row of superblock: so top-right pixels are in the top and/or
    // top-right superblocks, both of which are already available.
    if blk_row_in_sb == 0 {
      return true;
    };

    // Rightmost column of superblock (and not the top row): so top-right pixels
    // fall in the right superblock, which is not available yet.
    if ((blk_col_in_sb + 1) << bw_in_mi_log2) >= sb_mi_size {
      return false;
    };

    // General case (neither top row nor rightmost column): check if the
    // top-right block is coded before the current block.
    let this_blk_index =
      (blk_row_in_sb << (MAX_MIB_SIZE_LOG2 - bw_in_mi_log2)) + blk_col_in_sb;
    let idx1 = this_blk_index / 8;
    let idx2 = this_blk_index % 8;
    let has_tr_table: &[u8] = get_has_tr_table(/*partition,*/ bsize);

    ((has_tr_table[idx1] >> idx2) & 1) != 0
  }
}

// Similar to the has_tr_* tables, but store if the bottom-left reference
// pixels are available.
static has_bl_4x4: &[u8] = &[
  84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 1, 1, 1, 84, 85, 85, 85,
  16, 17, 17, 17, 84, 85, 85, 85, 0, 0, 1, 0, 84, 85, 85, 85, 16, 17, 17, 17,
  84, 85, 85, 85, 0, 1, 1, 1, 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85,
  0, 0, 0, 0, 84, 85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 1, 1, 1, 84,
  85, 85, 85, 16, 17, 17, 17, 84, 85, 85, 85, 0, 0, 1, 0, 84, 85, 85, 85, 16,
  17, 17, 17, 84, 85, 85, 85, 0, 1, 1, 1, 84, 85, 85, 85, 16, 17, 17, 17, 84,
  85, 85, 85, 0, 0, 0, 0,
];
static has_bl_4x8: &[u8] = &[
  16, 17, 17, 17, 0, 1, 1, 1, 16, 17, 17, 17, 0, 0, 1, 0, 16, 17, 17, 17, 0,
  1, 1, 1, 16, 17, 17, 17, 0, 0, 0, 0, 16, 17, 17, 17, 0, 1, 1, 1, 16, 17, 17,
  17, 0, 0, 1, 0, 16, 17, 17, 17, 0, 1, 1, 1, 16, 17, 17, 17, 0, 0, 0, 0,
];
static has_bl_8x4: &[u8] = &[
  254, 255, 84, 85, 254, 255, 16, 17, 254, 255, 84, 85, 254, 255, 0, 1, 254,
  255, 84, 85, 254, 255, 16, 17, 254, 255, 84, 85, 254, 255, 0, 0, 254, 255,
  84, 85, 254, 255, 16, 17, 254, 255, 84, 85, 254, 255, 0, 1, 254, 255, 84,
  85, 254, 255, 16, 17, 254, 255, 84, 85, 254, 255, 0, 0,
];
static has_bl_8x8: &[u8] = &[
  84, 85, 16, 17, 84, 85, 0, 1, 84, 85, 16, 17, 84, 85, 0, 0, 84, 85, 16, 17,
  84, 85, 0, 1, 84, 85, 16, 17, 84, 85, 0, 0,
];
static has_bl_8x16: &[u8] =
  &[16, 17, 0, 1, 16, 17, 0, 0, 16, 17, 0, 1, 16, 17, 0, 0];
static has_bl_16x8: &[u8] =
  &[254, 84, 254, 16, 254, 84, 254, 0, 254, 84, 254, 16, 254, 84, 254, 0];
static has_bl_16x16: &[u8] = &[84, 16, 84, 0, 84, 16, 84, 0];
static has_bl_16x32: &[u8] = &[16, 0, 16, 0];
static has_bl_32x16: &[u8] = &[78, 14, 78, 14];
static has_bl_32x32: &[u8] = &[4, 4];
static has_bl_32x64: &[u8] = &[0];
static has_bl_64x32: &[u8] = &[34];
static has_bl_64x64: &[u8] = &[0];
static has_bl_64x128: &[u8] = &[0];
static has_bl_128x64: &[u8] = &[0];
static has_bl_128x128: &[u8] = &[0];
static has_bl_4x16: &[u8] = &[
  0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0,
  1, 1, 1, 0, 0, 0, 0,
];
static has_bl_16x4: &[u8] = &[
  254, 254, 254, 84, 254, 254, 254, 16, 254, 254, 254, 84, 254, 254, 254, 0,
  254, 254, 254, 84, 254, 254, 254, 16, 254, 254, 254, 84, 254, 254, 254, 0,
];
static has_bl_8x32: &[u8] = &[0, 1, 0, 0, 0, 1, 0, 0];
static has_bl_32x8: &[u8] = &[238, 78, 238, 14, 238, 78, 238, 14];
static has_bl_16x64: &[u8] = &[0, 0];
static has_bl_64x16: &[u8] = &[42, 42];

static has_bl_tables: &[&[u8]] = &[
  has_bl_4x4,     // 4x4
  has_bl_4x8,     // 4x8
  has_bl_8x4,     // 8x4
  has_bl_8x8,     // 8x8
  has_bl_8x16,    // 8x16
  has_bl_16x8,    // 16x8
  has_bl_16x16,   // 16x16
  has_bl_16x32,   // 16x32
  has_bl_32x16,   // 32x16
  has_bl_32x32,   // 32x32
  has_bl_32x64,   // 32x64
  has_bl_64x32,   // 64x32
  has_bl_64x64,   // 64x64
  has_bl_64x128,  // 64x128
  has_bl_128x64,  // 128x64
  has_bl_128x128, // 128x128
  has_bl_4x16,    // 4x16
  has_bl_16x4,    // 16x4
  has_bl_8x32,    // 8x32
  has_bl_32x8,    // 32x8
  has_bl_16x64,   // 16x64
  has_bl_64x16,   // 64x16
];

#[rustfmt::skip]
static has_bl_vert_8x8: &[u8] = &[
  254, 255, 16, 17, 254, 255, 0, 1, 254, 255, 16, 17, 254, 255, 0, 0,
  254, 255, 16, 17, 254, 255, 0, 1, 254, 255, 16, 17, 254, 255, 0, 0,
];
static has_bl_vert_16x16: &[u8] = &[254, 16, 254, 0, 254, 16, 254, 0];
static has_bl_vert_32x32: &[u8] = &[14, 14];
static has_bl_vert_64x64: &[u8] = &[2];

// The _vert_* tables are like the ordinary tables above, but describe the
// order we visit square blocks when doing a PARTITION_VERT_A or
// PARTITION_VERT_B. This is the same order as normal except for on the last
// split where we go vertically (TL, BL, TR, BR). We treat the rectangular block
// as a pair of squares, which means that these tables work correctly for both
// mixed vertical partition types.
//
// There are tables for each of the square sizes. Vertical rectangles (like
// BLOCK_16X32) use their respective "non-vert" table
static has_bl_vert_tables: &[&[u8]] = &[
  has_null,          // 4x4
  has_bl_4x8,        // 4x8
  has_null,          // 8x4
  has_bl_vert_8x8,   // 8x8
  has_bl_8x16,       // 8x16
  has_null,          // 16x8
  has_bl_vert_16x16, // 16x16
  has_bl_16x32,      // 16x32
  has_null,          // 32x16
  has_bl_vert_32x32, // 32x32
  has_bl_32x64,      // 32x64
  has_null,          // 64x32
  has_bl_vert_64x64, // 64x64
  has_bl_64x128,     // 64x128
  has_null,          // 128x64
  has_bl_128x128,    // 128x128
];

pub fn get_has_bl_table(
  /*partition: PartitionType, */ bsize: BlockSize,
) -> &'static [u8] {
  let ret: &[u8];
  // If this is a mixed vertical partition, look up bsize in orders_vert.
  /*if (partition == PARTITION_VERT_A || partition == PARTITION_VERT_B) {
    //assert(bsize < BLOCK_SIZES);
    ret = has_bl_vert_tables[bsize as usize];
  } else*/
  {
    ret = has_bl_tables[bsize as usize];
  }
  //debug_assert!(ret != ptr::has_null());
  ret
}

pub fn has_bottom_left(
  bsize: BlockSize, partition_bo: TileBlockOffset, bottom_available: bool,
  left_available: bool, tx_size: TxSize, row_off: usize, col_off: usize,
  _ss_x: usize, ss_y: usize,
) -> bool {
  if !bottom_available || !left_available {
    return false;
  };

  // Special case for 128x* blocks, when col_off is half the block width.
  // This is needed because 128x* superblocks are divided into 64x* blocks in
  // raster order
  // 128x128 SB is not supported yet by rav1e
  if bsize.width() > BLOCK_64X64.width() && col_off > 0 {
    let plane_bw_unit_64 = BLOCK_64X64.width_mi() >> _ss_x;
    let col_off_64 = col_off % plane_bw_unit_64;
    if col_off_64 == 0 {
      // We are at the left edge of top-right or bottom-right 64x* block.
      let plane_bh_unit_64 = BLOCK_64X64.height_mi() >> ss_y;
      let row_off_64 = row_off % plane_bh_unit_64;
      let plane_bh_unit = (bsize.height_mi() >> ss_y).min(plane_bh_unit_64);
      // Check if all bottom-left pixels are in the left 64x* block (which is
      // already coded).
      return row_off_64 + tx_size.height_mi() < plane_bh_unit;
    }
  }

  if col_off > 0 {
    // Bottom-left pixels are in the bottom-left block, which is not available.
    false
  } else {
    let bh_unit = bsize.height_mi();
    let plane_bh_unit = (bh_unit >> ss_y).max(1);
    let bottom_left_count_unit = tx_size.height_mi();

    let mi_col = partition_bo.0.x;
    let mi_row = partition_bo.0.y;

    // All bottom-left pixels are in the left block, which is already available.
    if row_off + bottom_left_count_unit < plane_bh_unit {
      return true;
    };

    let bw_in_mi_log2 = bsize.width_log2() - MI_SIZE_LOG2;
    let bh_in_mi_log2 = bsize.height_log2() - MI_SIZE_LOG2;
    let sb_mi_size: usize = 16; // 64x64
    let blk_row_in_sb = (mi_row & (sb_mi_size - 1)) >> bh_in_mi_log2;
    let blk_col_in_sb = (mi_col & (sb_mi_size - 1)) >> bw_in_mi_log2;

    // Leftmost column of superblock: so bottom-left pixels maybe in the left
    // and/or bottom-left superblocks. But only the left superblock is
    // available, so check if all required pixels fall in that superblock.
    if blk_col_in_sb == 0 {
      let blk_start_row_off = blk_row_in_sb << bh_in_mi_log2 >> ss_y;
      let row_off_in_sb = blk_start_row_off + row_off;
      let sb_height_unit = sb_mi_size >> ss_y;
      return row_off_in_sb + bottom_left_count_unit < sb_height_unit;
      //return row_off_in_sb + (bottom_left_count_unit << 1) < sb_height_unit;  // Don't it need tx height? again?
    }

    // Bottom row of superblock (and not the leftmost column): so bottom-left
    // pixels fall in the bottom superblock, which is not available yet.
    if ((blk_row_in_sb + 1) << bh_in_mi_log2) >= sb_mi_size {
      return false;
    };

    // General case (neither leftmost column nor bottom row): check if the
    // bottom-left block is coded before the current block.
    let this_blk_index =
      (blk_row_in_sb << (MAX_MIB_SIZE_LOG2 - bw_in_mi_log2)) + blk_col_in_sb;
    let idx1 = this_blk_index / 8;
    let idx2 = this_blk_index % 8;
    let has_bl_table: &[u8] = get_has_bl_table(/*partition,*/ bsize);

    ((has_bl_table[idx1] >> idx2) & 1) != 0
  }
}