use crate::{NotFoundException,ResultPoint};
use crate::aztec::AztecDetectorResult;
use crate::common::{BitMatrix,GridSampler};
use crate::common::detector::{MathUtils,WhiteRectangleDetector};
use crate::common::reedsolomon::{GenericGF,ReedSolomonDecoder,ReedSolomonException};


/**
 * Encapsulates logic that can detect an Aztec Code in an image, even if the Aztec Code
 * is rotated or skewed, or partially obscured.
 *
 * @author David Olivier
 * @author Frank Yellin
 */

const EXPECTED_CORNER_BITS: vec![Vec<i32>; 4] = vec![// 07340  XXX .XX X.. ...
0xee0, // 00734  ... XXX .XX X..
0x1dc, // 04073  X.. ... XXX .XX
0x83b, // 03407 .XX X.. ... XXX
0x707, ]
;
pub struct Detector {

     let image: BitMatrix;

     let mut compact: bool;

     let nb_layers: i32;

     let nb_data_blocks: i32;

     let nb_center_layers: i32;

     let mut shift: i32;
}

impl Detector {

    pub fn new( image: &BitMatrix) -> Detector {
        let .image = image;
    }

    pub fn  detect(&self) -> /*  throws NotFoundException */Result<AztecDetectorResult, Rc<Exception>>   {
        return Ok(self.detect(false));
    }

    /**
   * Detects an Aztec Code in an image.
   *
   * @param isMirror if true, image is a mirror-image of original
   * @return {@link AztecDetectorResult} encapsulating results of detecting an Aztec Code
   * @throws NotFoundException if no Aztec Code can be found
   */
    pub fn  detect(&self,  is_mirror: bool) -> /*  throws NotFoundException */Result<AztecDetectorResult, Rc<Exception>>   {
        // 1. Get the center of the aztec matrix
         let p_center: Point = self.get_matrix_center();
        // 2. Get the center points of the four diagonal points just outside the bull's eye
        //  [topRight, bottomRight, bottomLeft, topLeft]
         let bulls_eye_corners: Vec<ResultPoint> = self.get_bulls_eye_corners(p_center);
        if is_mirror {
             let temp: ResultPoint = bulls_eye_corners[0];
            bulls_eye_corners[0] = bulls_eye_corners[2];
            bulls_eye_corners[2] = temp;
        }
        // 3. Get the size of the matrix and other parameters from the bull's eye
        self.extract_parameters(bulls_eye_corners);
        // 4. Sample the grid
         let bits: BitMatrix = self.sample_grid(self.image, bulls_eye_corners[self.shift % 4], bulls_eye_corners[(self.shift + 1) % 4], bulls_eye_corners[(self.shift + 2) % 4], bulls_eye_corners[(self.shift + 3) % 4]);
        // 5. Get the corners of the matrix.
         let corners: Vec<ResultPoint> = self.get_matrix_corner_points(bulls_eye_corners);
        return Ok(AztecDetectorResult::new(bits, corners, self.compact, self.nb_data_blocks, self.nb_layers));
    }

    /**
   * Extracts the number of data layers and data blocks from the layer around the bull's eye.
   *
   * @param bullsEyeCorners the array of bull's eye corners
   * @throws NotFoundException in case of too many errors or invalid parameters
   */
    fn  extract_parameters(&self,  bulls_eye_corners: &Vec<ResultPoint>)  -> /*  throws NotFoundException */Result<Void, Rc<Exception>>   {
        if !self.is_valid(bulls_eye_corners[0]) || !self.is_valid(bulls_eye_corners[1]) || !self.is_valid(bulls_eye_corners[2]) || !self.is_valid(bulls_eye_corners[3]) {
            throw NotFoundException::get_not_found_instance();
        }
         let length: i32 = 2 * self.nb_center_layers;
        // Get the bits around the bull's eye
         let sides: vec![Vec<i32>; 4] = vec![// Right side
        self.sample_line(bulls_eye_corners[0], bulls_eye_corners[1], length), // Bottom
        self.sample_line(bulls_eye_corners[1], bulls_eye_corners[2], length), // Left side
        self.sample_line(bulls_eye_corners[2], bulls_eye_corners[3], length), // Top
        self.sample_line(bulls_eye_corners[3], bulls_eye_corners[0], length), ]
        ;
        // bullsEyeCorners[shift] is the corner of the bulls'eye that has three
        // orientation marks.
        // sides[shift] is the row/column that goes from the corner with three
        // orientation marks to the corner with two.
        self.shift = ::get_rotation(&sides, length);
        // Flatten the parameter bits into a single 28- or 40-bit long
         let parameter_data: i64 = 0;
         {
             let mut i: i32 = 0;
            while i < 4 {
                {
                     let side: i32 = sides[(self.shift + i) % 4];
                    if self.compact {
                        // Each side of the form ..XXXXXXX. where Xs are parameter data
                        parameter_data <<= 7;
                        parameter_data += (side >> 1) & 0x7F;
                    } else {
                        // Each side of the form ..XXXXX.XXXXX. where Xs are parameter data
                        parameter_data <<= 10;
                        parameter_data += ((side >> 2) & (0x1f << 5)) + ((side >> 1) & 0x1F);
                    }
                }
                i += 1;
             }
         }

        // Corrects parameter data using RS.  Returns just the data portion
        // without the error correction.
         let corrected_data: i32 = ::get_corrected_parameter_data(parameter_data, self.compact);
        if self.compact {
            // 8 bits:  2 bits layers and 6 bits data blocks
            self.nb_layers = (corrected_data >> 6) + 1;
            self.nb_data_blocks = (corrected_data & 0x3F) + 1;
        } else {
            // 16 bits:  5 bits layers and 11 bits data blocks
            self.nb_layers = (corrected_data >> 11) + 1;
            self.nb_data_blocks = (corrected_data & 0x7FF) + 1;
        }
    }

    fn  get_rotation( sides: &Vec<i32>,  length: i32) -> /*  throws NotFoundException */Result<i32, Rc<Exception>>   {
        // In a normal pattern, we expect to See
        //   **    .*             D       A
        //   *      *
        //
        //   .      *
        //   ..    ..             C       B
        //
        // Grab the 3 bits from each of the sides the form the locator pattern and concatenate
        // into a 12-bit integer.  Start with the bit at A
         let corner_bits: i32 = 0;
        for  let side: i32 in sides {
            // XX......X where X's are orientation marks
             let t: i32 = ((side >> (length - 2)) << 1) + (side & 1);
            corner_bits = (corner_bits << 3) + t;
        }
        // Mov the bottom bit to the top, so that the three bits of the locator pattern at A are
        // together.  cornerBits is now:
        //  3 orientation bits at A || 3 orientation bits at B || ... || 3 orientation bits at D
        corner_bits = ((corner_bits & 1) << 11) + (corner_bits >> 1);
        // can easily tolerate two errors.
         {
             let mut shift: i32 = 0;
            while shift < 4 {
                {
                    if Integer::bit_count(corner_bits ^ EXPECTED_CORNER_BITS[shift]) <= 2 {
                        return Ok(shift);
                    }
                }
                shift += 1;
             }
         }

        throw NotFoundException::get_not_found_instance();
    }

    /**
   * Corrects the parameter bits using Reed-Solomon algorithm.
   *
   * @param parameterData parameter bits
   * @param compact true if this is a compact Aztec code
   * @throws NotFoundException if the array contains too many errors
   */
    fn  get_corrected_parameter_data( parameter_data: i64,  compact: bool) -> /*  throws NotFoundException */Result<i32, Rc<Exception>>   {
         let num_codewords: i32;
         let num_data_codewords: i32;
        if compact {
            num_codewords = 7;
            num_data_codewords = 2;
        } else {
            num_codewords = 10;
            num_data_codewords = 4;
        }
         let num_e_c_codewords: i32 = num_codewords - num_data_codewords;
         let parameter_words: [i32; num_codewords] = [0; num_codewords];
         {
             let mut i: i32 = num_codewords - 1;
            while i >= 0 {
                {
                    parameter_words[i] = parameter_data as i32 & 0xF;
                    parameter_data >>= 4;
                }
                i -= 1;
             }
         }

        let tryResult1 = 0;
        'try1: loop {
        {
             let rs_decoder: ReedSolomonDecoder = ReedSolomonDecoder::new(GenericGF::AZTEC_PARAM);
            rs_decoder.decode(&parameter_words, num_e_c_codewords);
        }
        break 'try1
        }
        match tryResult1 {
             catch ( ignored: &ReedSolomonException) {
                throw NotFoundException::get_not_found_instance();
            }  0 => break
        }

        // Toss the error correction.  Just return the data as an integer
         let mut result: i32 = 0;
         {
             let mut i: i32 = 0;
            while i < num_data_codewords {
                {
                    result = (result << 4) + parameter_words[i];
                }
                i += 1;
             }
         }

        return Ok(result);
    }

    /**
   * Finds the corners of a bull-eye centered on the passed point.
   * This returns the centers of the diagonal points just outside the bull's eye
   * Returns [topRight, bottomRight, bottomLeft, topLeft]
   *
   * @param pCenter Center point
   * @return The corners of the bull-eye
   * @throws NotFoundException If no valid bull-eye can be found
   */
    fn  get_bulls_eye_corners(&self,  p_center: &Point) -> /*  throws NotFoundException */Result<Vec<ResultPoint>, Rc<Exception>>   {
         let mut pina: Point = p_center;
         let mut pinb: Point = p_center;
         let mut pinc: Point = p_center;
         let mut pind: Point = p_center;
         let mut color: bool = true;
         {
            self.nb_center_layers = 1;
            while self.nb_center_layers < 9 {
                {
                     let pouta: Point = self.get_first_different(pina, color, 1, -1);
                     let poutb: Point = self.get_first_different(pinb, color, 1, 1);
                     let poutc: Point = self.get_first_different(pinc, color, -1, 1);
                     let poutd: Point = self.get_first_different(pind, color, -1, -1);
                    if self.nb_center_layers > 2 {
                         let q: f32 = ::distance(poutd, pouta) * self.nb_center_layers / (::distance(pind, pina) * (self.nb_center_layers + 2));
                        if q < 0.75 || q > 1.25 || !self.is_white_or_black_rectangle(pouta, poutb, poutc, poutd) {
                            break;
                        }
                    }
                    pina = pouta;
                    pinb = poutb;
                    pinc = poutc;
                    pind = poutd;
                    color = !color;
                }
                self.nb_center_layers += 1;
             }
         }

        if self.nb_center_layers != 5 && self.nb_center_layers != 7 {
            throw NotFoundException::get_not_found_instance();
        }
        self.compact = self.nb_center_layers == 5;
        // Expand the square by .5 pixel in each direction so that we're on the border
        // between the white square and the black square
         let pinax: ResultPoint = ResultPoint::new(pina.get_x() + 0.5f, pina.get_y() - 0.5f);
         let pinbx: ResultPoint = ResultPoint::new(pinb.get_x() + 0.5f, pinb.get_y() + 0.5f);
         let pincx: ResultPoint = ResultPoint::new(pinc.get_x() - 0.5f, pinc.get_y() + 0.5f);
         let pindx: ResultPoint = ResultPoint::new(pind.get_x() - 0.5f, pind.get_y() - 0.5f);
        // just outside the bull's eye.
        return Ok(::expand_square( : vec![ResultPoint; 4] = vec![pinax, pinbx, pincx, pindx, ]
        , 2 * self.nb_center_layers - 3, 2 * self.nb_center_layers));
    }

    /**
   * Finds a candidate center point of an Aztec code from an image
   *
   * @return the center point
   */
    fn  get_matrix_center(&self) -> Point  {
         let point_a: ResultPoint;
         let point_b: ResultPoint;
         let point_c: ResultPoint;
         let point_d: ResultPoint;
        //Get a white rectangle that can be the border of the matrix in center bull's eye or
        let tryResult1 = 0;
        'try1: loop {
        {
             let corner_points: Vec<ResultPoint> = WhiteRectangleDetector::new(self.image).detect();
            point_a = corner_points[0];
            point_b = corner_points[1];
            point_c = corner_points[2];
            point_d = corner_points[3];
        }
        break 'try1
        }
        match tryResult1 {
             catch ( e: &NotFoundException) {
                 let cx: i32 = self.image.get_width() / 2;
                 let cy: i32 = self.image.get_height() / 2;
                point_a = self.get_first_different(Point::new(cx + 7, cy - 7), false, 1, -1).to_result_point();
                point_b = self.get_first_different(Point::new(cx + 7, cy + 7), false, 1, 1).to_result_point();
                point_c = self.get_first_different(Point::new(cx - 7, cy + 7), false, -1, 1).to_result_point();
                point_d = self.get_first_different(Point::new(cx - 7, cy - 7), false, -1, -1).to_result_point();
            }  0 => break
        }

        //Compute the center of the rectangle
         let mut cx: i32 = MathUtils::round((point_a.get_x() + point_d.get_x() + point_b.get_x() + point_c.get_x()) / 4.0f);
         let mut cy: i32 = MathUtils::round((point_a.get_y() + point_d.get_y() + point_b.get_y() + point_c.get_y()) / 4.0f);
        // in order to compute a more accurate center.
        let tryResult1 = 0;
        'try1: loop {
        {
             let corner_points: Vec<ResultPoint> = WhiteRectangleDetector::new(self.image, 15, cx, cy).detect();
            point_a = corner_points[0];
            point_b = corner_points[1];
            point_c = corner_points[2];
            point_d = corner_points[3];
        }
        break 'try1
        }
        match tryResult1 {
             catch ( e: &NotFoundException) {
                point_a = self.get_first_different(Point::new(cx + 7, cy - 7), false, 1, -1).to_result_point();
                point_b = self.get_first_different(Point::new(cx + 7, cy + 7), false, 1, 1).to_result_point();
                point_c = self.get_first_different(Point::new(cx - 7, cy + 7), false, -1, 1).to_result_point();
                point_d = self.get_first_different(Point::new(cx - 7, cy - 7), false, -1, -1).to_result_point();
            }  0 => break
        }

        // Recompute the center of the rectangle
        cx = MathUtils::round((point_a.get_x() + point_d.get_x() + point_b.get_x() + point_c.get_x()) / 4.0f);
        cy = MathUtils::round((point_a.get_y() + point_d.get_y() + point_b.get_y() + point_c.get_y()) / 4.0f);
        return Point::new(cx, cy);
    }

    /**
   * Gets the Aztec code corners from the bull's eye corners and the parameters.
   *
   * @param bullsEyeCorners the array of bull's eye corners
   * @return the array of aztec code corners
   */
    fn  get_matrix_corner_points(&self,  bulls_eye_corners: &Vec<ResultPoint>) -> Vec<ResultPoint>  {
        return ::expand_square(bulls_eye_corners, 2 * self.nb_center_layers, &self.get_dimension());
    }

    /**
   * Creates a BitMatrix by sampling the provided image.
   * topLeft, topRight, bottomRight, and bottomLeft are the centers of the squares on the
   * diagonal just outside the bull's eye.
   */
    fn  sample_grid(&self,  image: &BitMatrix,  top_left: &ResultPoint,  top_right: &ResultPoint,  bottom_right: &ResultPoint,  bottom_left: &ResultPoint) -> /*  throws NotFoundException */Result<BitMatrix, Rc<Exception>>   {
         let sampler: GridSampler = GridSampler::get_instance();
         let dimension: i32 = self.get_dimension();
         let low: f32 = dimension / 2.0f - self.nb_center_layers;
         let high: f32 = dimension / 2.0f + self.nb_center_layers;
        return Ok(sampler.sample_grid(image, dimension, dimension, // topleft
        low, // topleft
        low, // topright
        high, // topright
        low, // bottomright
        high, // bottomright
        high, // bottomleft
        low, // bottomleft
        high, &top_left.get_x(), &top_left.get_y(), &top_right.get_x(), &top_right.get_y(), &bottom_right.get_x(), &bottom_right.get_y(), &bottom_left.get_x(), &bottom_left.get_y()));
    }

    /**
   * Samples a line.
   *
   * @param p1   start point (inclusive)
   * @param p2   end point (exclusive)
   * @param size number of bits
   * @return the array of bits as an int (first bit is high-order bit of result)
   */
    fn  sample_line(&self,  p1: &ResultPoint,  p2: &ResultPoint,  size: i32) -> i32  {
         let mut result: i32 = 0;
         let d: f32 = ::distance(p1, p2);
         let module_size: f32 = d / size;
         let px: f32 = p1.get_x();
         let py: f32 = p1.get_y();
         let dx: f32 = module_size * (p2.get_x() - p1.get_x()) / d;
         let dy: f32 = module_size * (p2.get_y() - p1.get_y()) / d;
         {
             let mut i: i32 = 0;
            while i < size {
                {
                    if self.image.get(&MathUtils::round(px + i * dx), &MathUtils::round(py + i * dy)) {
                        result |= 1 << (size - i - 1);
                    }
                }
                i += 1;
             }
         }

        return result;
    }

    /**
   * @return true if the border of the rectangle passed in parameter is compound of white points only
   *         or black points only
   */
    fn  is_white_or_black_rectangle(&self,  p1: &Point,  p2: &Point,  p3: &Point,  p4: &Point) -> bool  {
         let corr: i32 = 3;
        p1 = Point::new(&Math::max(0, p1.get_x() - corr), &Math::min(self.image.get_height() - 1, p1.get_y() + corr));
        p2 = Point::new(&Math::max(0, p2.get_x() - corr), &Math::max(0, p2.get_y() - corr));
        p3 = Point::new(&Math::min(self.image.get_width() - 1, p3.get_x() + corr), &Math::max(0, &Math::min(self.image.get_height() - 1, p3.get_y() - corr)));
        p4 = Point::new(&Math::min(self.image.get_width() - 1, p4.get_x() + corr), &Math::min(self.image.get_height() - 1, p4.get_y() + corr));
         let c_init: i32 = self.get_color(p4, p1);
        if c_init == 0 {
            return false;
        }
         let mut c: i32 = self.get_color(p1, p2);
        if c != c_init {
            return false;
        }
        c = self.get_color(p2, p3);
        if c != c_init {
            return false;
        }
        c = self.get_color(p3, p4);
        return c == c_init;
    }

    /**
   * Gets the color of a segment
   *
   * @return 1 if segment more than 90% black, -1 if segment is more than 90% white, 0 else
   */
    fn  get_color(&self,  p1: &Point,  p2: &Point) -> i32  {
         let d: f32 = ::distance(p1, p2);
        if d == 0.0f {
            return 0;
        }
         let dx: f32 = (p2.get_x() - p1.get_x()) / d;
         let dy: f32 = (p2.get_y() - p1.get_y()) / d;
         let mut error: i32 = 0;
         let mut px: f32 = p1.get_x();
         let mut py: f32 = p1.get_y();
         let color_model: bool = self.image.get(&p1.get_x(), &p1.get_y());
         let i_max: i32 = Math::floor(d) as i32;
         {
             let mut i: i32 = 0;
            while i < i_max {
                {
                    if self.image.get(&MathUtils::round(px), &MathUtils::round(py)) != color_model {
                        error += 1;
                    }
                    px += dx;
                    py += dy;
                }
                i += 1;
             }
         }

         let err_ratio: f32 = error / d;
        if err_ratio > 0.1f && err_ratio < 0.9f {
            return 0;
        }
        return  if (err_ratio <= 0.1f) == color_model { 1 } else { -1 };
    }

    /**
   * Gets the coordinate of the first point with a different color in the given direction
   */
    fn  get_first_different(&self,  init: &Point,  color: bool,  dx: i32,  dy: i32) -> Point  {
         let mut x: i32 = init.get_x() + dx;
         let mut y: i32 = init.get_y() + dy;
        while self.is_valid(x, y) && self.image.get(x, y) == color {
            x += dx;
            y += dy;
        }
        x -= dx;
        y -= dy;
        while self.is_valid(x, y) && self.image.get(x, y) == color {
            x += dx;
        }
        x -= dx;
        while self.is_valid(x, y) && self.image.get(x, y) == color {
            y += dy;
        }
        y -= dy;
        return Point::new(x, y);
    }

    /**
   * Expand the square represented by the corner points by pushing out equally in all directions
   *
   * @param cornerPoints the corners of the square, which has the bull's eye at its center
   * @param oldSide the original length of the side of the square in the target bit matrix
   * @param newSide the new length of the size of the square in the target bit matrix
   * @return the corners of the expanded square
   */
    fn  expand_square( corner_points: &Vec<ResultPoint>,  old_side: i32,  new_side: i32) -> Vec<ResultPoint>  {
         let ratio: f32 = new_side / (2.0f * old_side);
         let mut dx: f32 = corner_points[0].get_x() - corner_points[2].get_x();
         let mut dy: f32 = corner_points[0].get_y() - corner_points[2].get_y();
         let mut centerx: f32 = (corner_points[0].get_x() + corner_points[2].get_x()) / 2.0f;
         let mut centery: f32 = (corner_points[0].get_y() + corner_points[2].get_y()) / 2.0f;
         let result0: ResultPoint = ResultPoint::new(centerx + ratio * dx, centery + ratio * dy);
         let result2: ResultPoint = ResultPoint::new(centerx - ratio * dx, centery - ratio * dy);
        dx = corner_points[1].get_x() - corner_points[3].get_x();
        dy = corner_points[1].get_y() - corner_points[3].get_y();
        centerx = (corner_points[1].get_x() + corner_points[3].get_x()) / 2.0f;
        centery = (corner_points[1].get_y() + corner_points[3].get_y()) / 2.0f;
         let result1: ResultPoint = ResultPoint::new(centerx + ratio * dx, centery + ratio * dy);
         let result3: ResultPoint = ResultPoint::new(centerx - ratio * dx, centery - ratio * dy);
        return  : vec![ResultPoint; 4] = vec![result0, result1, result2, result3, ]
        ;
    }

    fn  is_valid(&self,  x: i32,  y: i32) -> bool  {
        return x >= 0 && x < self.image.get_width() && y >= 0 && y < self.image.get_height();
    }

    fn  is_valid(&self,  point: &ResultPoint) -> bool  {
         let x: i32 = MathUtils::round(&point.get_x());
         let y: i32 = MathUtils::round(&point.get_y());
        return self.is_valid(x, y);
    }

    fn  distance( a: &Point,  b: &Point) -> f32  {
        return MathUtils::distance(&a.get_x(), &a.get_y(), &b.get_x(), &b.get_y());
    }

    fn  distance( a: &ResultPoint,  b: &ResultPoint) -> f32  {
        return MathUtils::distance(&a.get_x(), &a.get_y(), &b.get_x(), &b.get_y());
    }

    fn  get_dimension(&self) -> i32  {
        if self.compact {
            return 4 * self.nb_layers + 11;
        }
        return 4 * self.nb_layers + 2 * ((2 * self.nb_layers + 6) / 15) + 15;
    }

    struct Point {

         let x: i32;

         let y: i32;
    }
    
    impl Point {

        fn  to_result_point(&self) -> ResultPoint  {
            return ResultPoint::new(self.x, self.y);
        }

        fn new( x: i32,  y: i32) -> Point {
            let .x = x;
            let .y = y;
        }

        fn  get_x(&self) -> i32  {
            return self.x;
        }

        fn  get_y(&self) -> i32  {
            return self.y;
        }

        pub fn  to_string(&self) -> String  {
            return format!("<{} {}>", self.x, self.y);
        }
    }

}