figrs/

v_main.rs

// --------------------------------------------------------------------------
// main vertical smush routines (excluding rules)

/*
      txt1 - A line of text
      txt2 - A line of text
      opts - FIGlet options array

      About: Takes in two lines of text and returns one of the following:
      "valid" - These lines can be smushed together given the current smushing rules
      "end" - The lines can be smushed, but we're at a stopping point
      "invalid" - The two lines cannot be smushed together
  */

// Import necessary libraries and modules
use std::cmp;

use crate::layout::LayoutType;
use crate::options::Options;
use crate::uni_smush::uni_smush;
use crate::rules::v_rule1_smush;
use crate::rules::v_rule2_smush;
use crate::rules::v_rule3_smush;
use crate::rules::v_rule4_smush;
use crate::rules::v_rule5_smush;

// Define a function to determine if two lines can be vertically smushed
fn can_vertical_smush<'a>(txt1: &'a str, txt2: &'a str, opts: &Options) -> &'a str {
    if opts.fitting_rules.v_layout == LayoutType::FullWidth {
        return "invalid";
    }

    let len = cmp::min(txt1.len(), txt2.len());

    if len == 0 {
        return "invalid";
    }

    let mut end_smush = false;

    for (ch1, ch2) in txt1.chars().zip(txt2.chars()) {
        if ch1 != ' ' && ch2 != ' ' {
            if opts.fitting_rules.v_layout == LayoutType::Fitting {
                return "invalid";
            } else if opts.fitting_rules.v_layout == LayoutType::Smushing {
                return "end";
            } else {
                if ch1 == '|' && ch2 == '|' {
                    continue;
                }
                let mut valid_smush = opts.fitting_rules.v_rule1 && v_rule1_smush(ch1, ch2).is_some();
                valid_smush = !valid_smush && opts.fitting_rules.v_rule2 && v_rule2_smush(ch1, ch2).is_some();
                valid_smush = !valid_smush && opts.fitting_rules.v_rule3 && v_rule3_smush(ch1, ch2).is_some();
                valid_smush = !valid_smush && opts.fitting_rules.v_rule4 && v_rule4_smush(ch1, ch2).is_some();
                end_smush = true;
                if valid_smush {
                    return "invalid";
                }
            }
        }
    }

    if end_smush {
        "end"
    } else {
        "valid"
    }
}

// Define a function to calculate the maximum vertical smush distance
fn get_vertical_smush_dist(lines1: &Vec<String>, lines2: &Vec<String>, opts: &Options) -> usize {
    let max_dist = lines1.len();
    let len1 = lines1.len();
    // let len2 = lines2.len();
    let mut cur_dist = 1;
    let mut result = String::new();

    while cur_dist <= max_dist {
        let sub_lines1 = &lines1[(len1.saturating_sub(cur_dist))..len1];
        let sub_lines2 = &lines2[0..cmp::min(max_dist, cur_dist)];

        let slen = sub_lines2.len();
        result.clear();

        for ii in 0..slen {
            let ret = can_vertical_smush(&sub_lines1[ii], &sub_lines2[ii], opts);
            if ret == "end" {
                result = ret.to_string();
            } else if ret == "invalid" {
                result = ret.to_string();
                break;
            } else if result.is_empty() {
                result = "valid".to_string();
            }
        }

        if result == "invalid" {
            cur_dist -= 1;
            break;
        }

        if result == "end" {
            break;
        }

        if result == "valid" {
            cur_dist += 1;
        }
    }

    cmp::min(max_dist, cur_dist)
}

// Define a function to vertically smush two lines
fn vertically_smush_lines(line1: &str, line2: &str, opts: &Options) -> String {
    let mut result = String::new();

    for (ch1, ch2) in line1.chars().zip(line2.chars()) {
        if ch1 != ' ' && ch2 != ' ' {
            if opts.fitting_rules.v_layout == LayoutType::Fitting {
                result.push(uni_smush(ch1, ch2, &' '));
            } else if opts.fitting_rules.v_layout == LayoutType::Smushing {
                result.push(uni_smush(ch1, ch2, &' '));
            } else {
                let mut valid_smush: Option<char> = None;
                valid_smush = if opts.fitting_rules.v_rule5 { v_rule5_smush(ch1, ch2) } else { valid_smush };
                valid_smush = if valid_smush.is_none() && opts.fitting_rules.v_rule1 { v_rule1_smush(ch1, ch2) } else { valid_smush };
                valid_smush = if valid_smush.is_none() && opts.fitting_rules.v_rule2 { v_rule2_smush(ch1, ch2) } else { valid_smush };
                valid_smush = if valid_smush.is_none() && opts.fitting_rules.v_rule3 { v_rule3_smush(ch1, ch2) } else { valid_smush };
                valid_smush = if valid_smush.is_none() && opts.fitting_rules.v_rule4 { v_rule4_smush(ch1, ch2) } else { valid_smush };

                if valid_smush.is_some() {
                    result.push(valid_smush.unwrap());
                }
            }
        } else {
            result.push(uni_smush(ch1, ch2, &' '));
        }
    }

    result
}

// Define a function to vertically smush two sets of lines with overlap
fn vertical_smush(lines1: &Vec<String>, lines2: &Vec<String>, overlap: usize, opts: &Options) -> Vec<String> {
    let len1 = lines1.len();
    let len2 = lines2.len();
    let piece1 = lines1[0..cmp::max(0, len1.saturating_sub(overlap))].to_vec();
    let piece2_1 = lines1[cmp::max(0, len1.saturating_sub(overlap))..len1].to_vec();
    let piece2_2 = lines2[0..cmp::min(overlap, len2)].to_vec();

    let mut piece2 = vec![];
    // let mut result = vec![];

    let len = piece2_1.len();
    for ii in 0..len {
        let line: String;
        if ii >= len2 {
            line = piece2_1[ii].clone();
        } else {
            line = vertically_smush_lines(&piece2_1[ii], &piece2_2[ii], opts);
        }
        piece2.push(line);
    }

    let piece3 = lines2[cmp::min(overlap, len2)..len2].to_vec();

    let mut output = vec![];
    output.extend_from_slice(&piece1);
    output.extend_from_slice(&piece2);
    output.extend_from_slice(&piece3);
    let scope = output[0].len() - lines1[0].len();
    pad_lines(&mut output, scope);

    output
}


// Define a function to pad lines with spaces
fn pad_lines(lines: &mut Vec<String>, num_spaces: usize) {
    let padding: String = " ".repeat(num_spaces);
    for line in lines.iter_mut() {
        line.push_str(&padding);
    }
}

// Define a function to smush vertical FIGlet lines
pub fn smush_vertical_fig_lines(output: &mut Vec<String>, lines: &mut Vec<String>, opts: &Options) -> Vec<String> {
    let len1 = output[0].len();
    let len2 = lines[0].len();

    // Add padding to lines if needed
    if len1 > len2 {
        pad_lines(lines, len1 - len2);
    } else if len2 > len1 {
        pad_lines(output, len2 - len1);
    }

    // Calculate the maximum vertical smush distance
    let overlap = get_vertical_smush_dist(output, lines, opts);

    vertical_smush(output, lines, overlap, opts)
}