use crate::prelude::*;

use crate::{encoding, prelude::*};

            encoding,

            encoding: _,

                Some(try_decode_contents(raw_contents, encoding))

                let encoding = encoding::detect(&raw_contents);
                Some(try_decode_contents(raw_contents, &encoding))

            encoding,

            encoding: _,

            let contents = try_decode_contents(raw_contents, encoding);

            let encoding = encoding::detect(&raw_contents);
            let contents = try_decode_contents(raw_contents, &encoding);

            encoding,

            encoding: _e,

            let encoding = encoding::detect(&raw_change_contents);
            let change_contents =
                try_decode_contents(raw_change_contents, &encoding);

            let change_contents =
                try_decode_contents(raw_change_contents, encoding);

            let encoding = encoding::detect(&raw_replacement_contents);

                try_decode_contents(raw_replacement_contents, encoding);

                try_decode_contents(raw_replacement_contents, &encoding);

pub mod encoding;

use crate::prelude::pijul;
/// Binary data returns `None`.
// Detection logic borrowed from <https://github.com/Wilfred/difftastic/blob/1436c8eac39dcea07f8c24a8128284a25b416e8d/src/files.rs#L141>.
pub fn detect(data: &[u8]) -> Option<pijul::Encoding> {
    if std::str::from_utf8(data).is_ok() {
        return Some(pijul::Encoding(encoding_rs::UTF_8));
    }
    // Only consider the first 1,000 bytes, as tree_magic_mini
    // considers the entire file, which is very slow on large files.
    let mut magic_bytes = data;
    if magic_bytes.len() > 1000 {
        magic_bytes = &magic_bytes[..1000];
    }
    let mime = tree_magic_mini::from_u8(magic_bytes);
    dbg!(mime);
    // Use MIME type detection to guess whether a file is binary. This
    // has false positives and false negatives, so only check the MIME
    // type after allowing perfect text files (see issue #433).
    match mime {
        // Treat pdf as binary.
        "application/pdf" => return None,
        // application/* is a mix of stuff, application/json is fine
        // but application/zip is binary that often decodes as valid
        // UTF-16.
        //
        // See
        // <https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/MIME_types/Common_types>
        // for a list of MIME types.
        "application/x-archive"
        | "application/x-bzip"
        | "application/x-bzip2"
        | "application/x-7zip-compressed"
        | "application/gzip"
        | "application/zip"
        | "application/zstd"
        | "application/octet-stream" => return None,
        // Treat all image content as binary.
        v if v.starts_with("image/") => return None,
        // Treat all audio content as binary.
        v if v.starts_with("audio/") => return None,
        // Treat all video content as binary.
        v if v.starts_with("video/") => return None,
        // Treat all font content as binary.
        v if v.starts_with("font/") => return None,
        _ => {}
    }
    // If the input bytes are *almost* valid UTF-8, treat them as
    // UTF-8. This is helpful when the user has written a small number
    // of bad bytes to a file. Users would still like to be able to
    // diff these files.
    let utf8_string = String::from_utf8_lossy(data).to_string();
    let num_utf8_invalid = utf8_string
        .chars()
        .take(50000)
        .filter(|c| *c == std::char::REPLACEMENT_CHARACTER || *c == '\0')
        .count();
    if num_utf8_invalid <= 2 {
        return Some(pijul::Encoding(encoding_rs::UTF_8));
    }
    // Fallback to pijul encoding detection
    pijul::change::get_encoding(data)
}

[dependencies.encoding_rs]
workspace = true

workspace = true
[dependencies.tree_magic_mini]

use libflorescence::encoding;

        let encoding = detect_encoding(&data);

        let encoding = encoding::detect(&data);

    }
}
// Detection logic borrowed from <https://github.com/Wilfred/difftastic/blob/1436c8eac39dcea07f8c24a8128284a25b416e8d/src/files.rs#L141>.
/// Binary data returns `None`
fn detect_encoding(data: &[u8]) -> Option<pijul::Encoding> {
    if std::str::from_utf8(data).is_ok() {
        return Some(pijul::Encoding(encoding_rs::UTF_8));
    }
    // Only consider the first 1,000 bytes, as tree_magic_mini
    // considers the entire file, which is very slow on large files.
    let mut magic_bytes = data;
    if magic_bytes.len() > 1000 {
        magic_bytes = &magic_bytes[..1000];
    }
    let mime = tree_magic_mini::from_u8(magic_bytes);
    // Use MIME type detection to guess whether a file is binary. This
    // has false positives and false negatives, so only check the MIME
    // type after allowing perfect text files (see issue #433).
    match mime {
        // Treat pdf as binary.
        "application/pdf" => return None,
        // application/* is a mix of stuff, application/json is fine
        // but application/zip is binary that often decodes as valid
        // UTF-16.
        //
        // See
        // <https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/MIME_types/Common_types>
        // for a list of MIME types.
        "application/x-archive" => return None,
        "application/x-bzip" => return None,
        "application/x-bzip2" => return None,
        "application/x-7zip-compressed" => return None,
        "application/gzip" => return None,
        "application/zip" => return None,
        "application/zstd" => return None,
        // Treat all image content as binary.
        v if v.starts_with("image/") => return None,
        // Treat all audio content as binary.
        v if v.starts_with("audio/") => return None,
        // Treat all video content as binary.
        v if v.starts_with("video/") => return None,
        // Treat all font content as binary.
        v if v.starts_with("font/") => return None,
        _ => {}

    // If the input bytes are *almost* valid UTF-8, treat them as
    // UTF-8. This is helpful when the user has written a small number
    // of bad bytes to a file. Users would still like to be able to
    // diff these files.
    let utf8_string = String::from_utf8_lossy(data).to_string();
    let num_utf8_invalid = utf8_string
        .chars()
        .take(50000)
        .filter(|c| *c == std::char::REPLACEMENT_CHARACTER || *c == '\0')
        .count();
    if num_utf8_invalid <= 2 {
        return Some(pijul::Encoding(encoding_rs::UTF_8));
    }
    // Fallback to pijul encoding detection
    pijul::change::get_encoding(data)

use tracing::error;

                (repo::Contents::UnknownEncoding(_change), repo::Contents::UnknownEncoding(_replacement)) => {

                (_, repo::Contents::UnknownEncoding(_)) |
                (repo::Contents::UnknownEncoding(_), _) => {

                    unimplemented!("The change and replacement have different encoding!");

                    error!("The change and replacement have different encoding! Change: {change_contents:?}, replacement: {replacement_contents:?}");
                    without.push(DiffWithoutContents::Replacement {
                        line: *line,
                        change_contents: UndecodableContents::UnknownEncoding,
                        replacement_contents: UndecodableContents::UnknownEncoding,
                    });

workspace = true
[dependencies.encoding_rs]

workspace = true
[dependencies.tree_magic_mini]

 "encoding_rs",

 "tree_magic_mini",

 "encoding_rs",

 "tree_magic_mini",