/*
 * Copyright 2021 ZXing authors
 *
 * 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.
 */
// package com::google::zxing::datamatrix::encoder;

/**
 * Encoder that encodes minimally
 *
 * Algorithm:
 *
 * Uses Dijkstra to produce mathematically minimal encodings that are in some cases smaller than the results produced
 * by the algorithm described in annex S in the specification ISO/IEC 16022:200(E). The biggest improvment of this
 * algorithm over that one is the case when the algorithm enters the most inefficient mode, the B256 mode. The 
 * algorithm from the specification algorithm will exit this mode only if it encounters digits so that arbitrarily
 * inefficient results can be produced if the postfix contains no digits.
 *
 * Multi ECI support and ECI switching:
 *
 * For multi language content the algorithm selects the most compact representation using ECI modes. Note that unlike
 * the compaction algorithm used for QR-Codes, this implementation operates in two stages and therfore is not
 * mathematically optimal. In the first stage, the input string is encoded minimally as a stream of ECI character set
 * selectors and bytes encoded in the selected encoding. In this stage the algorithm might for example decide to
 * encode ocurrences of the characters "\u0150\u015C" (O-double-acute, S-circumflex) in UTF-8 by a single ECI or
 * alternatively by multiple ECIs that switch between IS0-8859-2 and ISO-8859-3 (e.g. in the case that the input
 * contains many * characters from ISO-8859-2 (Latin 2) and few from ISO-8859-3 (Latin 3)).
 * In a second stage this stream of ECIs and bytes is minimally encoded using the various Data Matrix encoding modes.
 * While both stages encode mathematically minimally it is not ensured that the result is mathematically minimal since
 * the size growth for inserting an ECI in the first stage can only be approximated as the first stage does not know 
 * in which mode the ECI will occur in the second stage (may, or may not require an extra latch to ASCII depending on
 * the current mode). The reason for this shortcoming are difficulties in implementing it in a straightforward and
 * readable manner.
 *
 * GS1 support
 *
 * FNC1 delimiters can be encoded in the input string by using the FNC1 character specified in the encoding function.
 * When a FNC1 character is specified then a leading FNC1 will be encoded and all ocurrences of delimiter characters
 * while result in FNC1 codewords in the symbol.
 *
 * @author Alex Geller
 */

 const C40_SHIFT2_CHARS: vec![Vec<char>; 27] = vec!['!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '_', ]
;
pub struct MinimalEncoder {
}

impl MinimalEncoder {

    enum Mode {

        ASCII(), C40(), TEXT(), X12(), EDF(), B256()
    }

    fn new() -> MinimalEncoder {
    }

    fn  is_extended_a_s_c_i_i( ch: char,  fnc1: i32) -> bool  {
        return ch != fnc1 && ch >= 128 && ch <= 255;
    }

    fn  is_in_c40_shift1_set( ch: char) -> bool  {
        return ch <= 31;
    }

    fn  is_in_c40_shift2_set( ch: char,  fnc1: i32) -> bool  {
        for  let c40_shift2_char: char in C40_SHIFT2_CHARS {
            if c40_shift2_char == ch {
                return true;
            }
        }
        return ch == fnc1;
    }

    fn  is_in_text_shift1_set( ch: char) -> bool  {
        return ::is_in_c40_shift1_set(ch);
    }

    fn  is_in_text_shift2_set( ch: char,  fnc1: i32) -> bool  {
        return ::is_in_c40_shift2_set(ch, fnc1);
    }

    pub fn  encode_high_level( msg: &String) -> String  {
        return ::encode_high_level(&msg, null, -1, SymbolShapeHint::FORCE_NONE);
    }

    pub fn  encode_high_level( msg: &String,  priority_charset: &Charset,  fnc1: i32,  shape: &SymbolShapeHint) -> String  {
         let macro_id: i32 = 0;
        if msg.starts_with(HighLevelEncoder::MACRO_05_HEADER) && msg.ends_with(HighLevelEncoder::MACRO_TRAILER) {
            macro_id = 5;
            msg = msg.substring(&HighLevelEncoder::MACRO_05_HEADER::length(), msg.length() - 2);
        } else if msg.starts_with(HighLevelEncoder::MACRO_06_HEADER) && msg.ends_with(HighLevelEncoder::MACRO_TRAILER) {
            macro_id = 6;
            msg = msg.substring(&HighLevelEncoder::MACRO_06_HEADER::length(), msg.length() - 2);
        }
        return String::new(&::encode(&msg, &priority_charset, fnc1, shape, macro_id), StandardCharsets::ISO_8859_1);
    }

    fn  encode( input: &String,  priority_charset: &Charset,  fnc1: i32,  shape: &SymbolShapeHint,  macro_id: i32) -> Vec<i8>  {
        return ::encode_minimally(Input::new(&input, &priority_charset, fnc1, shape, macro_id)).get_bytes();
    }

    fn  add_edge( edges: &Vec<Vec<Edge>>,  edge: &Edge)   {
         let vertex_index: i32 = edge.fromPosition + edge.characterLength;
        if edges[vertex_index][edge.get_end_mode().ordinal()] == null || edges[vertex_index][edge.get_end_mode().ordinal()].cachedTotalSize > edge.cachedTotalSize {
            edges[vertex_index][edge.get_end_mode().ordinal()] = edge;
        }
    }

    fn  get_number_of_c40_words( input: &Input,  from: i32,  c40: bool,  character_length: &Vec<i32>) -> i32  {
         let thirds_count: i32 = 0;
         {
             let mut i: i32 = from;
            while i < input.length() {
                {
                    if input.is_e_c_i(i) {
                        character_length[0] = 0;
                        return 0;
                    }
                     let ci: char = input.char_at(i);
                    if c40 && HighLevelEncoder::is_native_c40(ci) || !c40 && HighLevelEncoder::is_native_text(ci) {
                        thirds_count += 1;
                    } else if !::is_extended_a_s_c_i_i(ci, &input.get_f_n_c1_character()) {
                        thirds_count += 2;
                    } else {
                         let ascii_value: i32 = ci & 0xff;
                        if ascii_value >= 128 && (c40 && HighLevelEncoder::is_native_c40((ascii_value - 128) as char) || !c40 && HighLevelEncoder::is_native_text((ascii_value - 128) as char)) {
                            thirds_count += 3;
                        } else {
                            thirds_count += 4;
                        }
                    }
                    if thirds_count % 3 == 0 || ((thirds_count - 2) % 3 == 0 && i + 1 == input.length()) {
                        character_length[0] = i - from + 1;
                        return Math::ceil((thirds_count as f64) / 3.0) as i32;
                    }
                }
                i += 1;
             }
         }

        character_length[0] = 0;
        return 0;
    }

    fn  add_edges( input: &Input,  edges: &Vec<Vec<Edge>>,  from: i32,  previous: &Edge)   {
        if input.is_e_c_i(from) {
            ::add_edge(edges, Edge::new(input, Mode::ASCII, from, 1, previous));
            return;
        }
         let ch: char = input.char_at(from);
        if previous == null || previous.get_end_mode() != Mode::EDF {
            if HighLevelEncoder::is_digit(ch) && input.have_n_characters(from, 2) && HighLevelEncoder::is_digit(&input.char_at(from + 1)) {
                ::add_edge(edges, Edge::new(input, Mode::ASCII, from, 2, previous));
            } else {
                ::add_edge(edges, Edge::new(input, Mode::ASCII, from, 1, previous));
            }
             let modes: vec![Vec<Mode>; 2] = vec![Mode::C40, Mode::TEXT, ]
            ;
            for  let mode: Mode in modes {
                 let character_length: [i32; 1] = [0; 1];
                if ::get_number_of_c40_words(input, from, mode == Mode::C40, &character_length) > 0 {
                    ::add_edge(edges, Edge::new(input, mode, from, character_length[0], previous));
                }
            }
            if input.have_n_characters(from, 3) && HighLevelEncoder::is_native_x12(&input.char_at(from)) && HighLevelEncoder::is_native_x12(&input.char_at(from + 1)) && HighLevelEncoder::is_native_x12(&input.char_at(from + 2)) {
                ::add_edge(edges, Edge::new(input, Mode::X12, from, 3, previous));
            }
            ::add_edge(edges, Edge::new(input, Mode::B256, from, 1, previous));
        }
        //unless it is 2 characters away from the end of the input.
         let mut i: i32;
         {
            i = 0;
            while i < 3 {
                {
                     let pos: i32 = from + i;
                    if input.have_n_characters(pos, 1) && HighLevelEncoder::is_native_e_d_i_f_a_c_t(&input.char_at(pos)) {
                        ::add_edge(edges, Edge::new(input, Mode::EDF, from, i + 1, previous));
                    } else {
                        break;
                    }
                }
                i += 1;
             }
         }

        if i == 3 && input.have_n_characters(from, 4) && HighLevelEncoder::is_native_e_d_i_f_a_c_t(&input.char_at(from + 3)) {
            ::add_edge(edges, Edge::new(input, Mode::EDF, from, 4, previous));
        }
    }

    fn  encode_minimally( input: &Input) -> Result  {
         let input_length: i32 = input.length();
        // Array that represents vertices. There is a vertex for every character and mode.
        // The last dimension in the array below encodes the 6 modes ASCII, C40, TEXT, X12, EDF and B256
         let mut edges: [[Option<Edge>; 6]; input_length + 1] = [[None; 6]; input_length + 1];
        ::add_edges(input, edges, 0, null);
         {
             let mut i: i32 = 1;
            while i <= input_length {
                {
                     {
                         let mut j: i32 = 0;
                        while j < 6 {
                            {
                                if edges[i][j] != null && i < input_length {
                                    ::add_edges(input, edges, i, edges[i][j]);
                                }
                            }
                            j += 1;
                         }
                     }

                    //optimize memory by removing edges that have been passed.
                     {
                         let mut j: i32 = 0;
                        while j < 6 {
                            {
                                edges[i - 1][j] = null;
                            }
                            j += 1;
                         }
                     }

                }
                i += 1;
             }
         }

         let minimal_j: i32 = -1;
         let minimal_size: i32 = Integer::MAX_VALUE;
         {
             let mut j: i32 = 0;
            while j < 6 {
                {
                    if edges[input_length][j] != null {
                         let edge: Edge = edges[input_length][j];
                        //C40, TEXT and X12 need an
                         let size: i32 =  if j >= 1 && j <= 3 { edge.cachedTotalSize + 1 } else { edge.cachedTotalSize };
                        // extra unlatch at the end
                        if size < minimal_size {
                            minimal_size = size;
                            minimal_j = j;
                        }
                    }
                }
                j += 1;
             }
         }

        if minimal_j < 0 {
            throw RuntimeException::new(format!("Internal error: failed to encode \"{}\"", input));
        }
        return Result::new(edges[input_length][minimal_j]);
    }


     let all_codeword_capacities: vec![Vec<i32>; 28] = vec![3, 5, 8, 10, 12, 16, 18, 22, 30, 32, 36, 44, 49, 62, 86, 114, 144, 174, 204, 280, 368, 456, 576, 696, 816, 1050, 1304, 1558, ]
    ;

     let square_codeword_capacities: vec![Vec<i32>; 24] = vec![3, 5, 8, 12, 18, 22, 30, 36, 44, 62, 86, 114, 144, 174, 204, 280, 368, 456, 576, 696, 816, 1050, 1304, 1558, ]
    ;

     let rectangular_codeword_capacities: vec![Vec<i32>; 6] = vec![5, 10, 16, 33, 32, 49, ]
    ;
    struct Edge {

         let input: Input;

        //the mode at the start of this edge.
         let mode: Mode;

         let from_position: i32;

         let character_length: i32;

         let previous: Edge;

         let cached_total_size: i32;
    }
    
    impl Edge {

        fn new( input: &Input,  mode: &Mode,  from_position: i32,  character_length: i32,  previous: &Edge) -> Edge {
            let .input = input;
            let .mode = mode;
            let .fromPosition = from_position;
            let .characterLength = character_length;
            let .previous = previous;
            assert!( from_position + character_length <= input.length());
             let mut size: i32 =  if previous != null { previous.cachedTotalSize } else { 0 };
             let previous_mode: Mode = self.get_previous_mode();
            /*
      * Switching modes
      * ASCII -> C40: latch 230
      * ASCII -> TEXT: latch 239
      * ASCII -> X12: latch 238
      * ASCII -> EDF: latch 240
      * ASCII -> B256: latch 231
      * C40 -> ASCII: word(c1,c2,c3), 254
      * TEXT -> ASCII: word(c1,c2,c3), 254
      * X12 -> ASCII: word(c1,c2,c3), 254
      * EDIFACT -> ASCII: Unlatch character,0,0,0 or c1,Unlatch character,0,0 or c1,c2,Unlatch character,0 or 
      * c1,c2,c3,Unlatch character
      * B256 -> ASCII: without latch after n bytes
      */
            match mode {
                  ASCII => 
                     {
                        size += 1;
                        if input.is_e_c_i(from_position) || ::is_extended_a_s_c_i_i(&input.char_at(from_position), &input.get_f_n_c1_character()) {
                            size += 1;
                        }
                        if previous_mode == Mode::C40 || previous_mode == Mode::TEXT || previous_mode == Mode::X12 {
                            // unlatch 254 to ASCII
                            size += 1;
                        }
                        break;
                    }
                  B256 => 
                     {
                        size += 1;
                        if previous_mode != Mode::B256 {
                            //byte count
                            size += 1;
                        } else if self.get_b256_size() == 250 {
                            //extra byte count
                            size += 1;
                        }
                        if previous_mode == Mode::ASCII {
                            //latch to B256
                            size += 1;
                        } else if previous_mode == Mode::C40 || previous_mode == Mode::TEXT || previous_mode == Mode::X12 {
                            //unlatch to ASCII, latch to B256
                            size += 2;
                        }
                        break;
                    }
                  C40 => 
                     {
                    }
                  TEXT => 
                     {
                    }
                  X12 => 
                     {
                        if mode == Mode::X12 {
                            size += 2;
                        } else {
                             let char_len: [i32; 1] = [0; 1];
                            size += ::get_number_of_c40_words(input, from_position, mode == Mode::C40, &char_len) * 2;
                        }
                        if previous_mode == Mode::ASCII || previous_mode == Mode::B256 {
                            //additional byte for latch from ASCII to this mode
                            size += 1;
                        } else if previous_mode != mode && (previous_mode == Mode::C40 || previous_mode == Mode::TEXT || previous_mode == Mode::X12) {
                            //unlatch 254 to ASCII followed by latch to this mode
                            size += 2;
                        }
                        break;
                    }
                  EDF => 
                     {
                        size += 3;
                        if previous_mode == Mode::ASCII || previous_mode == Mode::B256 {
                            //additional byte for latch from ASCII to this mode
                            size += 1;
                        } else if previous_mode == Mode::C40 || previous_mode == Mode::TEXT || previous_mode == Mode::X12 {
                            //unlatch 254 to ASCII followed by latch to this mode
                            size += 2;
                        }
                        break;
                    }
            }
            cached_total_size = size;
        }

        // does not count beyond 250
        fn  get_b256_size(&self) -> i32  {
             let mut cnt: i32 = 0;
             let mut current: Edge = self;
            while current != null && current.mode == Mode::B256 && cnt <= 250 {
                cnt += 1;
                current = current.previous;
            }
            return cnt;
        }

        fn  get_previous_start_mode(&self) -> Mode  {
            return  if self.previous == null { Mode::ASCII } else { self.previous.mode };
        }

        fn  get_previous_mode(&self) -> Mode  {
            return  if self.previous == null { Mode::ASCII } else { self.previous.get_end_mode() };
        }

        /** Returns Mode.ASCII in case that:
     *  - Mode is EDIFACT and characterLength is less than 4 or the remaining characters can be encoded in at most 2
     *    ASCII bytes.
     *  - Mode is C40, TEXT or X12 and the remaining characters can be encoded in at most 1 ASCII byte.
     *  Returns mode in all other cases.
     * */
        fn  get_end_mode(&self) -> Mode  {
            if self.mode == Mode::EDF {
                if self.character_length < 4 {
                    return Mode::ASCII;
                }
                // see 5.2.8.2 EDIFACT encodation Rules
                 let last_a_s_c_i_i: i32 = self.get_last_a_s_c_i_i();
                if last_a_s_c_i_i > 0 && self.get_codewords_remaining(self.cached_total_size + last_a_s_c_i_i) <= 2 - last_a_s_c_i_i {
                    return Mode::ASCII;
                }
            }
            if self.mode == Mode::C40 || self.mode == Mode::TEXT || self.mode == Mode::X12 {
                // see 5.2.5.2 C40 encodation rules and 5.2.7.2 ANSI X12 encodation rules
                if self.from_position + self.character_length >= self.input.length() && self.get_codewords_remaining(self.cached_total_size) == 0 {
                    return Mode::ASCII;
                }
                 let last_a_s_c_i_i: i32 = self.get_last_a_s_c_i_i();
                if last_a_s_c_i_i == 1 && self.get_codewords_remaining(self.cached_total_size + 1) == 0 {
                    return Mode::ASCII;
                }
            }
            return self.mode;
        }

        fn  get_mode(&self) -> Mode  {
            return self.mode;
        }

        /** Peeks ahead and returns 1 if the postfix consists of exactly two digits, 2 if the postfix consists of exactly
     *  two consecutive digits and a non extended character or of 4 digits. 
     *  Returns 0 in any other case
     **/
        fn  get_last_a_s_c_i_i(&self) -> i32  {
             let length: i32 = self.input.length();
             let from: i32 = self.from_position + self.character_length;
            if length - from > 4 || from >= length {
                return 0;
            }
            if length - from == 1 {
                if ::is_extended_a_s_c_i_i(&self.input.char_at(from), &self.input.get_f_n_c1_character()) {
                    return 0;
                }
                return 1;
            }
            if length - from == 2 {
                if ::is_extended_a_s_c_i_i(&self.input.char_at(from), &self.input.get_f_n_c1_character()) || ::is_extended_a_s_c_i_i(&self.input.char_at(from + 1), &self.input.get_f_n_c1_character()) {
                    return 0;
                }
                if HighLevelEncoder::is_digit(&self.input.char_at(from)) && HighLevelEncoder::is_digit(&self.input.char_at(from + 1)) {
                    return 1;
                }
                return 2;
            }
            if length - from == 3 {
                if HighLevelEncoder::is_digit(&self.input.char_at(from)) && HighLevelEncoder::is_digit(&self.input.char_at(from + 1)) && !::is_extended_a_s_c_i_i(&self.input.char_at(from + 2), &self.input.get_f_n_c1_character()) {
                    return 2;
                }
                if HighLevelEncoder::is_digit(&self.input.char_at(from + 1)) && HighLevelEncoder::is_digit(&self.input.char_at(from + 2)) && !::is_extended_a_s_c_i_i(&self.input.char_at(from), &self.input.get_f_n_c1_character()) {
                    return 2;
                }
                return 0;
            }
            if HighLevelEncoder::is_digit(&self.input.char_at(from)) && HighLevelEncoder::is_digit(&self.input.char_at(from + 1)) && HighLevelEncoder::is_digit(&self.input.char_at(from + 2)) && HighLevelEncoder::is_digit(&self.input.char_at(from + 3)) {
                return 2;
            }
            return 0;
        }

        /** Returns the capacity in codewords of the smallest symbol that has enough capacity to fit the given minimal
     * number of codewords.
     **/
        fn  get_min_symbol_size(&self,  minimum: i32) -> i32  {
            match self.input.get_shape_hint() {
                  FORCE_SQUARE => 
                     {
                        for  let capacity: i32 in square_codeword_capacities {
                            if capacity >= minimum {
                                return capacity;
                            }
                        }
                        break;
                    }
                  FORCE_RECTANGLE => 
                     {
                        for  let capacity: i32 in rectangular_codeword_capacities {
                            if capacity >= minimum {
                                return capacity;
                            }
                        }
                        break;
                    }
            }
            for  let capacity: i32 in all_codeword_capacities {
                if capacity >= minimum {
                    return capacity;
                }
            }
            return all_codeword_capacities[all_codeword_capacities.len() - 1];
        }

        /** Returns the remaining capacity in codewords of the smallest symbol that has enough capacity to fit the given
     * minimal number of codewords.
     **/
        fn  get_codewords_remaining(&self,  minimum: i32) -> i32  {
            return self.get_min_symbol_size(minimum) - minimum;
        }

        fn  get_bytes( c: i32) -> Vec<i8>  {
             let mut result: [i8; 1] = [0; 1];
            result[0] = c as i8;
            return result;
        }

        fn  get_bytes( c1: i32,  c2: i32) -> Vec<i8>  {
             let mut result: [i8; 2] = [0; 2];
            result[0] = c1 as i8;
            result[1] = c2 as i8;
            return result;
        }

        fn  set_c40_word( bytes: &Vec<i8>,  offset: i32,  c1: i32,  c2: i32,  c3: i32)   {
             let val16: i32 = (1600 * (c1 & 0xff)) + (40 * (c2 & 0xff)) + (c3 & 0xff) + 1;
            bytes[offset] = (val16 / 256) as i8;
            bytes[offset + 1] = (val16 % 256) as i8;
        }

        fn  get_x12_value( c: char) -> i32  {
            return  if c == 13 { 0 } else {  if c == 42 { 1 } else {  if c == 62 { 2 } else {  if c == 32 { 3 } else {  if c >= 48 && c <= 57 { c - 44 } else {  if c >= 65 && c <= 90 { c - 51 } else { c } } } } } };
        }

        fn  get_x12_words(&self) -> Vec<i8>  {
            assert!( self.character_length % 3 == 0);
             let result: [i8; self.character_length / 3 * 2] = [0; self.character_length / 3 * 2];
             {
                 let mut i: i32 = 0;
                while i < result.len() {
                    {
                        ::set_c40_word(&result, i, &::get_x12_value(&self.input.char_at(self.from_position + i / 2 * 3)), &::get_x12_value(&self.input.char_at(self.from_position + i / 2 * 3 + 1)), &::get_x12_value(&self.input.char_at(self.from_position + i / 2 * 3 + 2)));
                    }
                    i += 2;
                 }
             }

            return result;
        }

        fn  get_shift_value( c: char,  c40: bool,  fnc1: i32) -> i32  {
            return  if (c40 && ::is_in_c40_shift1_set(c) || !c40 && ::is_in_text_shift1_set(c)) { 0 } else {  if (c40 && ::is_in_c40_shift2_set(c, fnc1) || !c40 && ::is_in_text_shift2_set(c, fnc1)) { 1 } else { 2 } };
        }

        fn  get_c40_value( c40: bool,  set_index: i32,  c: char,  fnc1: i32) -> i32  {
            if c == fnc1 {
                assert!( set_index == 2);
                return 27;
            }
            if c40 {
                return  if c <= 31 { c } else {  if c == 32 { 3 } else {  if c <= 47 { c - 33 } else {  if c <= 57 { c - 44 } else {  if c <= 64 { c - 43 } else {  if c <= 90 { c - 51 } else {  if c <= 95 { c - 69 } else {  if c <= 127 { c - 96 } else { c } } } } } } } };
            } else {
                return  if c == 0 { 0 } else {  if //is this a bug in the spec?
                set_index == 0 && c <= 3 { //is this a bug in the spec?
                c - 1 } else {  if set_index == 1 && c <= 31 { c } else {  if c == 32 { 3 } else {  if c >= 33 && c <= 47 { c - 33 } else {  if c >= 48 && c <= 57 { c - 44 } else {  if c >= 58 && c <= 64 { c - 43 } else {  if c >= 65 && c <= 90 { c - 64 } else {  if c >= 91 && c <= 95 { c - 69 } else {  if c == 96 { 0 } else {  if c >= 97 && c <= 122 { c - 83 } else {  if c >= 123 && c <= 127 { c - 96 } else { c } } } } } } } } } } } };
            }
        }

        fn  get_c40_words(&self,  c40: bool,  fnc1: i32) -> Vec<i8>  {
             let c40_values: List<Byte> = ArrayList<>::new();
             {
                 let mut i: i32 = 0;
                while i < self.character_length {
                    {
                         let ci: char = self.input.char_at(self.from_position + i);
                        if c40 && HighLevelEncoder::is_native_c40(ci) || !c40 && HighLevelEncoder::is_native_text(ci) {
                            c40_values.add(::get_c40_value(c40, 0, ci, fnc1) as i8);
                        } else if !::is_extended_a_s_c_i_i(ci, fnc1) {
                             let shift_value: i32 = ::get_shift_value(ci, c40, fnc1);
                            //Shift[123]
                            c40_values.add(shift_value as i8);
                            c40_values.add(::get_c40_value(c40, shift_value, ci, fnc1) as i8);
                        } else {
                             let ascii_value: char = ((ci & 0xff) - 128) as char;
                            if c40 && HighLevelEncoder::is_native_c40(ascii_value) || !c40 && HighLevelEncoder::is_native_text(ascii_value) {
                                //Shift 2
                                c40_values.add(1 as i8);
                                //Upper Shift
                                c40_values.add(30 as i8);
                                c40_values.add(::get_c40_value(c40, 0, ascii_value, fnc1) as i8);
                            } else {
                                //Shift 2
                                c40_values.add(1 as i8);
                                //Upper Shift
                                c40_values.add(30 as i8);
                                 let shift_value: i32 = ::get_shift_value(ascii_value, c40, fnc1);
                                // Shift[123]
                                c40_values.add(shift_value as i8);
                                c40_values.add(::get_c40_value(c40, shift_value, ascii_value, fnc1) as i8);
                            }
                        }
                    }
                    i += 1;
                 }
             }

            if (c40_values.size() % 3) != 0 {
                assert!( (c40_values.size() - 2) % 3 == 0 && self.from_position + self.character_length == self.input.length());
                // pad with 0 (Shift 1)
                c40_values.add(0 as i8);
            }
             let result: [i8; c40_values.size() / 3 * 2] = [0; c40_values.size() / 3 * 2];
             let byte_index: i32 = 0;
             {
                 let mut i: i32 = 0;
                while i < c40_values.size() {
                    {
                        ::set_c40_word(&result, byte_index, c40_values.get(i) & 0xff, c40_values.get(i + 1) & 0xff, c40_values.get(i + 2) & 0xff);
                        byte_index += 2;
                    }
                    i += 3;
                 }
             }

            return result;
        }

        fn  get_e_d_f_bytes(&self) -> Vec<i8>  {
             let number_of_thirds: i32 = Math::ceil(self.character_length / 4.0) as i32;
             let mut result: [i8; number_of_thirds * 3] = [0; number_of_thirds * 3];
             let mut pos: i32 = self.from_position;
             let end_pos: i32 = Math::min(self.from_position + self.character_length - 1, self.input.length() - 1);
             {
                 let mut i: i32 = 0;
                while i < number_of_thirds {
                    {
                         let edf_values: [i32; 4] = [0; 4];
                         {
                             let mut j: i32 = 0;
                            while j < 4 {
                                {
                                    if pos <= end_pos {
                                        edf_values[j] = self.input.char_at(pos += 1 !!!check!!! post increment) & 0x3f;
                                    } else {
                                        edf_values[j] =  if pos == end_pos + 1 { 0x1f } else { 0 };
                                    }
                                }
                                j += 1;
                             }
                         }

                         let mut val24: i32 = edf_values[0] << 18;
                        val24 |= edf_values[1] << 12;
                        val24 |= edf_values[2] << 6;
                        val24 |= edf_values[3];
                        result[i] = ((val24 >> 16) & 0xff) as i8;
                        result[i + 1] = ((val24 >> 8) & 0xff) as i8;
                        result[i + 2] = (val24 & 0xff) as i8;
                    }
                    i += 3;
                 }
             }

            return result;
        }

        fn  get_latch_bytes(&self) -> Vec<i8>  {
            match self.get_previous_mode() {
                  ASCII => 
                     {
                    }
                  //after B256 ends (via length) we are back to ASCII
                B256 => 
                     {
                        match self.mode {
                              B256 => 
                                 {
                                    return ::get_bytes(231);
                                }
                              C40 => 
                                 {
                                    return ::get_bytes(230);
                                }
                              TEXT => 
                                 {
                                    return ::get_bytes(239);
                                }
                              X12 => 
                                 {
                                    return ::get_bytes(238);
                                }
                              EDF => 
                                 {
                                    return ::get_bytes(240);
                                }
                        }
                        break;
                    }
                  C40 => 
                     {
                    }
                  TEXT => 
                     {
                    }
                  X12 => 
                     {
                        if self.mode != self.get_previous_mode() {
                            match self.mode {
                                  ASCII => 
                                     {
                                        return ::get_bytes(254);
                                    }
                                  B256 => 
                                     {
                                        return ::get_bytes(254, 231);
                                    }
                                  C40 => 
                                     {
                                        return ::get_bytes(254, 230);
                                    }
                                  TEXT => 
                                     {
                                        return ::get_bytes(254, 239);
                                    }
                                  X12 => 
                                     {
                                        return ::get_bytes(254, 238);
                                    }
                                  EDF => 
                                     {
                                        return ::get_bytes(254, 240);
                                    }
                            }
                        }
                        break;
                    }
                  EDF => 
                     {
                        //The rightmost EDIFACT edge always contains an unlatch character
                        assert!( self.mode == Mode::EDF);
                        break;
                    }
            }
            return : [i8; 0] = [0; 0];
        }

        // Important: The function does not return the length bytes (one or two) in case of B256 encoding
        fn  get_data_bytes(&self) -> Vec<i8>  {
            match self.mode {
                  ASCII => 
                     {
                        if self.input.is_e_c_i(self.from_position) {
                            return ::get_bytes(241, self.input.get_e_c_i_value(self.from_position) + 1);
                        } else if ::is_extended_a_s_c_i_i(&self.input.char_at(self.from_position), &self.input.get_f_n_c1_character()) {
                            return ::get_bytes(235, self.input.char_at(self.from_position) - 127);
                        } else if self.character_length == 2 {
                            return ::get_bytes((self.input.char_at(self.from_position) - '0') * 10 + self.input.char_at(self.from_position + 1) - '0' + 130);
                        } else if self.input.is_f_n_c1(self.from_position) {
                            return ::get_bytes(232);
                        } else {
                            return ::get_bytes(self.input.char_at(self.from_position) + 1);
                        }
                    }
                  B256 => 
                     {
                        return ::get_bytes(&self.input.char_at(self.from_position));
                    }
                  C40 => 
                     {
                        return self.get_c40_words(true, &self.input.get_f_n_c1_character());
                    }
                  TEXT => 
                     {
                        return self.get_c40_words(false, &self.input.get_f_n_c1_character());
                    }
                  X12 => 
                     {
                        return self.get_x12_words();
                    }
                  EDF => 
                     {
                        return self.get_e_d_f_bytes();
                    }
            }
            assert!( false);
            return : [i8; 0] = [0; 0];
        }
    }


    struct Result {

         let mut bytes: Vec<i8>;
    }
    
    impl Result {

        fn new( solution: &Edge) -> Result {
             let input: Input = solution.input;
             let mut size: i32 = 0;
             let bytes_a_l: List<Byte> = ArrayList<>::new();
             let randomize_postfix_length: List<Integer> = ArrayList<>::new();
             let randomize_lengths: List<Integer> = ArrayList<>::new();
            if (solution.mode == Mode::C40 || solution.mode == Mode::TEXT || solution.mode == Mode::X12) && solution.get_end_mode() != Mode::ASCII {
                size += ::prepend(&MinimalEncoder::Edge::get_bytes(254), &bytes_a_l);
            }
             let mut current: Edge = solution;
            while current != null {
                size += ::prepend(&current.get_data_bytes(), &bytes_a_l);
                if current.previous == null || current.get_previous_start_mode() != current.get_mode() {
                    if current.get_mode() == Mode::B256 {
                        if size <= 249 {
                            bytes_a_l.add(0, size as i8);
                            size += 1;
                        } else {
                            bytes_a_l.add(0, (size % 250) as i8);
                            bytes_a_l.add(0, (size / 250 + 249) as i8);
                            size += 2;
                        }
                        randomize_postfix_length.add(&bytes_a_l.size());
                        randomize_lengths.add(size);
                    }
                    ::prepend(&current.get_latch_bytes(), &bytes_a_l);
                    size = 0;
                }
                current = current.previous;
            }
            if input.get_macro_id() == 5 {
                size += ::prepend(&MinimalEncoder::Edge::get_bytes(236), &bytes_a_l);
            } else if input.get_macro_id() == 6 {
                size += ::prepend(&MinimalEncoder::Edge::get_bytes(237), &bytes_a_l);
            }
            if input.get_f_n_c1_character() > 0 {
                size += ::prepend(&MinimalEncoder::Edge::get_bytes(232), &bytes_a_l);
            }
             {
                 let mut i: i32 = 0;
                while i < randomize_postfix_length.size() {
                    {
                        ::apply_random_pattern(&bytes_a_l, bytes_a_l.size() - randomize_postfix_length.get(i), &randomize_lengths.get(i));
                    }
                    i += 1;
                 }
             }

            //add padding
             let capacity: i32 = solution.get_min_symbol_size(&bytes_a_l.size());
            if bytes_a_l.size() < capacity {
                bytes_a_l.add(129 as i8);
            }
            while bytes_a_l.size() < capacity {
                bytes_a_l.add(::randomize253_state(bytes_a_l.size() + 1) as i8);
            }
            bytes = : [i8; bytes_a_l.size()] = [0; bytes_a_l.size()];
             {
                 let mut i: i32 = 0;
                while i < bytes.len() {
                    {
                        bytes[i] = bytes_a_l.get(i);
                    }
                    i += 1;
                 }
             }

        }

        fn  prepend( bytes: &Vec<i8>,  into: &List<Byte>) -> i32  {
             {
                 let mut i: i32 = bytes.len() - 1;
                while i >= 0 {
                    {
                        into.add(0, bytes[i]);
                    }
                    i -= 1;
                 }
             }

            return bytes.len();
        }

        fn  randomize253_state( codeword_position: i32) -> i32  {
             let pseudo_random: i32 = ((149 * codeword_position) % 253) + 1;
             let temp_variable: i32 = 129 + pseudo_random;
            return  if temp_variable <= 254 { temp_variable } else { temp_variable - 254 };
        }

        fn  apply_random_pattern( bytes_a_l: &List<Byte>,  start_position: i32,  length: i32)   {
             {
                 let mut i: i32 = 0;
                while i < length {
                    {
                        //See "B.1 253-state algorithm
                         const Pad_codeword_position: i32 = start_position + i;
                         const Pad_codeword_value: i32 = bytes_a_l.get(Pad_codeword_position) & 0xff;
                         let pseudo_random_number: i32 = ((149 * (Pad_codeword_position + 1)) % 255) + 1;
                         let temp_variable: i32 = Pad_codeword_value + pseudo_random_number;
                        bytes_a_l.set(Pad_codeword_position, ( if temp_variable <= 255 { temp_variable } else { temp_variable - 256 }) as i8);
                    }
                    i += 1;
                 }
             }

        }

        pub fn  get_bytes(&self) -> Vec<i8>  {
            return self.bytes;
        }
    }


    struct Input {
        super: MinimalECIInput;

         let shape: SymbolShapeHint;

         let macro_id: i32;
    }
    
    impl Input {

        fn new( string_to_encode: &String,  priority_charset: &Charset,  fnc1: i32,  shape: &SymbolShapeHint,  macro_id: i32) -> Input {
            super(&string_to_encode, &priority_charset, fnc1);
            let .shape = shape;
            let .macroId = macro_id;
        }

        fn  get_macro_id(&self) -> i32  {
            return self.macro_id;
        }

        fn  get_shape_hint(&self) -> SymbolShapeHint  {
            return self.shape;
        }
    }

}