use std::{char, collections::HashMap, fmt::Display};

use chrono::{NaiveTime, TimeDelta, Utc};

use crate::{errors::Error, DType};

/// Enum representing the different ops of diff

#[derive(Debug, PartialEq, Eq, Clone, Copy)]

pub enum Ops {

}

}

let mut data = diffs

.iter()

.map(|diff| {

match diff.op() {

Ops::Insert => {

// format!("+{encoded}")

}

Ops::Delete => {

}

Ops::Equal => {

}

}

})

}

#[inline]

diffs

.iter()

.filter_map(|diff| {

}

diffs

.iter()

.filter_map(|diff| {

// limit of the match algorithm.

// Intended to be called only from within patch_apply.

#[inline]

let max_bit = self.match_max_bits();

let patch_margin = self.patch_margin() as usize;

// Match methods

impl DiffMatchPatch {

// Check for null inputs.

// Nothing to match.

if text.is_empty() {

}

}

if pattern.len() > self.match_max_bits() {

todo!("Throw error");

}

best_loc

}

let mut map = HashMap::with_capacity(pattern.len());

pattern.iter().enumerate().for_each(|(i, &p)| {

}

// Patch Methods

start1: usize,

start2: usize,

length1: usize,

length2: usize,

}

fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

let coord1 = if self.length1 == 0 {

format!("{},0", self.start1)

coord2,

" @@\n".to_string(),

];

let sign = match diff.op() {

Ops::Insert => '+',

Ops::Delete => '-',

Ops::Equal => ' ',

};

segments.push(segment)

write!(f, "{}", segments.join(""))

}

}

&self.diffs[..]

}

}

Texts(&'a str, &'a str),

}

impl DiffMatchPatch {

let mut section = Vec::with_capacity(64);

let mut current_sect = 0;

let mut new_cols = None;

for &c in s.iter() {

match current_sect {

0 => {

return None;

}

}

return None;

}

let ol = splits.first()?;

if let Some(&oc) = splits.get(1) {

}

}

2 => {

.collect::<Vec<_>>();

let nl = splits.first()?;

if let Some(&nc) = splits.get(1) {

}

}

_ => {

continue;

}

return None;

}

section.push(c);

}

return None;

}

Some((old_line, old_cols, new_line, new_cols))

}

&self,

// No diffs -> no patches

if diffs.is_empty() {

return Ok(Vec::new());

let mut char_n1 = 0;

let mut char_n2 = 0;

diffs.iter().enumerate().for_each(|(idx, diff)| {

// a new patch starts here

Ok(patches)

}

if text.is_empty() {

return;

}

patch.length2 += prefix.len() + suffix.len();

}

&self,

if patches.is_empty() {

return Ok((source.to_vec(), vec![]));

}

Ok((source, results))

}

let pad_len = self.patch_margin() as usize;

let null_pad = (1..pad_len + 1)

.collect::<Vec<_>>();

// Bump all the patches forward.

/// Given a diff, measure its Levenshtein distance in terms of the number of inserted, deleted or substituted characters.

/// The minimum distance is 0 which means equality, the maximum distance is the length of the longer string.

let mut levenshtein = 0;

let mut insert = 0;

let mut delete = 0;

/// Given two texts, or an already computed list of differences, return an array of patch objects.

/// The third form PatchInput::TextDiffs(...) is preferred, use it if you happen to have that data available, otherwise this function will compute the missing pieces.

/// TODO: add example

let mut diff_input;

let txt_old;

let (txt, diffs) = match input {

// No diffs provided, lets make our own

PatchInput::Texts(txt1, txt2) => {

if diff_input.len() > 2 {

Self::cleanup_semantic(&mut diff_input);

}

}

PatchInput::Diffs(diffs) => {

// No origin string provided, compute our own.

}

};

}

/// Reduces an array of patch objects to a block of text which looks extremely similar to the standard GNU diff/patch format. This text may be stored or transmitted.

/// TODO: add example

patches.iter().map(|p| p.to_string()).collect::<String>()

}

/// Parses a block of text (which was presumably created by the patch_toText function) and returns an array of patch objects.

/// TODO: add example

if text.is_empty() {

return Ok(vec![]);

}

let mut patches = vec![];

};

// Should never panic, already checked for `empty`

}

text.remove(0);

/// If patch_delete_threshold is closer to 1, then the deleted text may contain anything.

/// In most use cases Patch_DeleteThreshold should just be set to the same value as match_threshold.

/// TODO: add example

&self,

source_txt: &str,

) -> Result<(String, Vec<bool>), crate::errors::Error> {

Ok((

results,

))

}