#ifndef INCLUDE_git_diff_h__

#define INCLUDE_git_diff_h__

#include "common.h"

#include "types.h"

#include "oid.h"

#include "tree.h"

#include "refs.h"

typedef enum {

/** Normal diff, the default */

GIT_DIFF_NORMAL = 0,

/*

/** Reverse the sides of the diff */

GIT_DIFF_REVERSE = (1u << 0),

/** Include ignored files in the diff */

GIT_DIFF_INCLUDE_IGNORED = (1u << 1),

/** Even with GIT_DIFF_INCLUDE_IGNORED, an entire ignored directory

GIT_DIFF_RECURSE_IGNORED_DIRS = (1u << 2),

/** Include untracked files in the diff */

GIT_DIFF_INCLUDE_UNTRACKED = (1u << 3),

/** Even with GIT_DIFF_INCLUDE_UNTRACKED, an entire untracked

GIT_DIFF_RECURSE_UNTRACKED_DIRS = (1u << 4),

/** Include unmodified files in the diff */

GIT_DIFF_INCLUDE_UNMODIFIED = (1u << 5),

/** Normally, a type change between files will be converted into a

GIT_DIFF_INCLUDE_TYPECHANGE = (1u << 6),

/** Even with GIT_DIFF_INCLUDE_TYPECHANGE, blob->tree changes still

GIT_DIFF_INCLUDE_TYPECHANGE_TREES = (1u << 7),

/** Ignore file mode changes */

GIT_DIFF_IGNORE_FILEMODE = (1u << 8),

/** Treat all submodules as unmodified */

GIT_DIFF_IGNORE_SUBMODULES = (1u << 9),

/** Use case insensitive filename comparisons */

GIT_DIFF_IGNORE_CASE = (1u << 10),

/** May be combined with `GIT_DIFF_IGNORE_CASE` to specify that a file

GIT_DIFF_INCLUDE_CASECHANGE = (1u << 11),

/** If the pathspec is set in the diff options, this flags indicates

GIT_DIFF_DISABLE_PATHSPEC_MATCH = (1u << 12),

/** Disable updating of the `binary` flag in delta records. This is

GIT_DIFF_SKIP_BINARY_CHECK = (1u << 13),

/** When diff finds an untracked directory, to match the behavior of

GIT_DIFF_ENABLE_FAST_UNTRACKED_DIRS = (1u << 14),

/** When diff finds a file in the working directory with stat

GIT_DIFF_UPDATE_INDEX = (1u << 15),

/** Include unreadable files in the diff */

GIT_DIFF_INCLUDE_UNREADABLE = (1u << 16),

/** Include unreadable files in the diff */

GIT_DIFF_INCLUDE_UNREADABLE_AS_UNTRACKED = (1u << 17),

/*

/** Treat all files as text, disabling binary attributes & detection */

GIT_DIFF_FORCE_TEXT = (1u << 20),

/** Treat all files as binary, disabling text diffs */

GIT_DIFF_FORCE_BINARY = (1u << 21),

/** Ignore all whitespace */

GIT_DIFF_IGNORE_WHITESPACE = (1u << 22),

/** Ignore changes in amount of whitespace */

GIT_DIFF_IGNORE_WHITESPACE_CHANGE = (1u << 23),

/** Ignore whitespace at end of line */

GIT_DIFF_IGNORE_WHITESPACE_EOL = (1u << 24),

/** When generating patch text, include the content of untracked

GIT_DIFF_SHOW_UNTRACKED_CONTENT = (1u << 25),

/** When generating output, include the names of unmodified files if

GIT_DIFF_SHOW_UNMODIFIED = (1u << 26),

/** Use the "patience diff" algorithm */

GIT_DIFF_PATIENCE = (1u << 28),

/** Take extra time to find minimal diff */

GIT_DIFF_MINIMAL = (1 << 29),

/** Include the necessary deflate / delta information so that `git-apply`

GIT_DIFF_SHOW_BINARY = (1 << 30),

} git_diff_option_t;

typedef struct git_diff git_diff;

typedef enum {

GIT_DIFF_FLAG_BINARY = (1u << 0), /**< file(s) treated as binary data */

GIT_DIFF_FLAG_NOT_BINARY = (1u << 1), /**< file(s) treated as text data */

GIT_DIFF_FLAG_VALID_ID = (1u << 2), /**< `id` value is known correct */

GIT_DIFF_FLAG_EXISTS = (1u << 3), /**< file exists at this side of the delta */

} git_diff_flag_t;

typedef enum {

GIT_DELTA_UNMODIFIED = 0, /**< no changes */

GIT_DELTA_ADDED = 1, /**< entry does not exist in old version */

GIT_DELTA_DELETED = 2, /**< entry does not exist in new version */

GIT_DELTA_MODIFIED = 3, /**< entry content changed between old and new */

GIT_DELTA_RENAMED = 4, /**< entry was renamed between old and new */

GIT_DELTA_COPIED = 5, /**< entry was copied from another old entry */

GIT_DELTA_IGNORED = 6, /**< entry is ignored item in workdir */

GIT_DELTA_UNTRACKED = 7, /**< entry is untracked item in workdir */

GIT_DELTA_TYPECHANGE = 8, /**< type of entry changed between old and new */

GIT_DELTA_UNREADABLE = 9, /**< entry is unreadable */

GIT_DELTA_CONFLICTED = 10, /**< entry in the index is conflicted */

} git_delta_t;

typedef struct {

git_oid id;

const char *path;

git_off_t size;

uint32_t flags;

uint16_t mode;

uint16_t id_abbrev;

} git_diff_file;

typedef struct {

git_delta_t status;

uint32_t flags; /**< git_diff_flag_t values */

uint16_t similarity; /**< for RENAMED and COPIED, value 0-100 */

uint16_t nfiles; /**< number of files in this delta */

git_diff_file old_file;

git_diff_file new_file;

} git_diff_delta;

typedef int (*git_diff_notify_cb)(

const git_diff *diff_so_far,

const git_diff_delta *delta_to_add,

const char *matched_pathspec,

void *payload);

typedef int (*git_diff_progress_cb)(

const git_diff *diff_so_far,

const char *old_path,

const char *new_path,

void *payload);

typedef struct {

unsigned int version; /**< version for the struct */

uint32_t flags; /**< defaults to GIT_DIFF_NORMAL */

/* options controlling which files are in the diff */

git_submodule_ignore_t ignore_submodules; /**< submodule ignore rule */

git_strarray pathspec; /**< defaults to include all paths */

git_diff_notify_cb notify_cb;

git_diff_progress_cb progress_cb;

void *payload;

/* options controlling how to diff text is generated */

uint32_t context_lines; /**< defaults to 3 */

uint32_t interhunk_lines; /**< defaults to 0 */

uint16_t id_abbrev; /**< default 'core.abbrev' or 7 if unset */

git_off_t max_size; /**< defaults to 512MB */

const char *old_prefix; /**< defaults to "a" */

const char *new_prefix; /**< defaults to "b" */

} git_diff_options;

#define GIT_DIFF_OPTIONS_VERSION 1

#define GIT_DIFF_OPTIONS_INIT \

{GIT_DIFF_OPTIONS_VERSION, 0, GIT_SUBMODULE_IGNORE_UNSPECIFIED, {NULL,0}, NULL, NULL, NULL, 3}

GIT_EXTERN(int) git_diff_init_options(

git_diff_options *opts,

unsigned int version);

typedef int (*git_diff_file_cb)(

const git_diff_delta *delta,

float progress,

void *payload);

#define GIT_DIFF_HUNK_HEADER_SIZE 128

typedef enum {

/** There is no binary delta. */

GIT_DIFF_BINARY_NONE,

/** The binary data is the literal contents of the file. */

GIT_DIFF_BINARY_LITERAL,

/** The binary data is the delta from one side to the other. */

GIT_DIFF_BINARY_DELTA,

} git_diff_binary_t;

typedef struct {

/** The type of binary data for this file. */

git_diff_binary_t type;

/** The binary data, deflated. */

const char *data;

/** The length of the binary data. */

size_t datalen;

/** The length of the binary data after inflation. */

size_t inflatedlen;

} git_diff_binary_file;

typedef struct {

/**

unsigned int contains_data;

git_diff_binary_file old_file; /**< The contents of the old file. */

git_diff_binary_file new_file; /**< The contents of the new file. */

} git_diff_binary;

typedef int(*git_diff_binary_cb)(

const git_diff_delta *delta,

const git_diff_binary *binary,

void *payload);

typedef struct {

int old_start; /** Starting line number in old_file */

int old_lines; /** Number of lines in old_file */

int new_start; /** Starting line number in new_file */

int new_lines; /** Number of lines in new_file */

size_t header_len; /** Number of bytes in header text */

char header[GIT_DIFF_HUNK_HEADER_SIZE]; /** Header text, NUL-byte terminated */

} git_diff_hunk;

typedef int (*git_diff_hunk_cb)(

const git_diff_delta *delta,

const git_diff_hunk *hunk,

void *payload);

typedef enum {

/* These values will be sent to `git_diff_line_cb` along with the line */

GIT_DIFF_LINE_CONTEXT = ' ',

GIT_DIFF_LINE_ADDITION = '+',

GIT_DIFF_LINE_DELETION = '-',

GIT_DIFF_LINE_CONTEXT_EOFNL = '=', /**< Both files have no LF at end */

GIT_DIFF_LINE_ADD_EOFNL = '>', /**< Old has no LF at end, new does */

GIT_DIFF_LINE_DEL_EOFNL = '<', /**< Old has LF at end, new does not */

/* The following values will only be sent to a `git_diff_line_cb` when

GIT_DIFF_LINE_FILE_HDR = 'F',

GIT_DIFF_LINE_HUNK_HDR = 'H',

GIT_DIFF_LINE_BINARY = 'B' /**< For "Binary files x and y differ" */

} git_diff_line_t;

typedef struct {

char origin; /**< A git_diff_line_t value */

int old_lineno; /**< Line number in old file or -1 for added line */

int new_lineno; /**< Line number in new file or -1 for deleted line */

int num_lines; /**< Number of newline characters in content */

size_t content_len; /**< Number of bytes of data */

git_off_t content_offset; /**< Offset in the original file to the content */

const char *content; /**< Pointer to diff text, not NUL-byte terminated */

} git_diff_line;

typedef int (*git_diff_line_cb)(

const git_diff_delta *delta, /**< delta that contains this data */

const git_diff_hunk *hunk, /**< hunk containing this data */

const git_diff_line *line, /**< line data */

void *payload); /**< user reference data */

typedef enum {

/** Obey `diff.renames`. Overridden by any other GIT_DIFF_FIND_... flag. */

GIT_DIFF_FIND_BY_CONFIG = 0,

/** Look for renames? (`--find-renames`) */

GIT_DIFF_FIND_RENAMES = (1u << 0),

/** Consider old side of MODIFIED for renames? (`--break-rewrites=N`) */

GIT_DIFF_FIND_RENAMES_FROM_REWRITES = (1u << 1),

/** Look for copies? (a la `--find-copies`). */

GIT_DIFF_FIND_COPIES = (1u << 2),

/** Consider UNMODIFIED as copy sources? (`--find-copies-harder`).

GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED = (1u << 3),

/** Mark significant rewrites for split (`--break-rewrites=/M`) */

GIT_DIFF_FIND_REWRITES = (1u << 4),

/** Actually split large rewrites into delete/add pairs */

GIT_DIFF_BREAK_REWRITES = (1u << 5),

/** Mark rewrites for split and break into delete/add pairs */

GIT_DIFF_FIND_AND_BREAK_REWRITES =

(GIT_DIFF_FIND_REWRITES | GIT_DIFF_BREAK_REWRITES),

/** Find renames/copies for UNTRACKED items in working directory.

GIT_DIFF_FIND_FOR_UNTRACKED = (1u << 6),

/** Turn on all finding features. */

GIT_DIFF_FIND_ALL = (0x0ff),

/** Measure similarity ignoring leading whitespace (default) */

GIT_DIFF_FIND_IGNORE_LEADING_WHITESPACE = 0,

/** Measure similarity ignoring all whitespace */

GIT_DIFF_FIND_IGNORE_WHITESPACE = (1u << 12),

/** Measure similarity including all data */

GIT_DIFF_FIND_DONT_IGNORE_WHITESPACE = (1u << 13),

/** Measure similarity only by comparing SHAs (fast and cheap) */

GIT_DIFF_FIND_EXACT_MATCH_ONLY = (1u << 14),

/** Do not break rewrites unless they contribute to a rename.

GIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY = (1u << 15),

/** Remove any UNMODIFIED deltas after find_similar is done.

GIT_DIFF_FIND_REMOVE_UNMODIFIED = (1u << 16),

} git_diff_find_t;

typedef struct {

int (*file_signature)(

void **out, const git_diff_file *file,

const char *fullpath, void *payload);

int (*buffer_signature)(

void **out, const git_diff_file *file,

const char *buf, size_t buflen, void *payload);

void (*free_signature)(void *sig, void *payload);

int (*similarity)(int *score, void *siga, void *sigb, void *payload);

void *payload;

} git_diff_similarity_metric;

typedef struct {

unsigned int version;

/**

uint32_t flags;

/** Similarity to consider a file renamed (default 50) */

uint16_t rename_threshold;

/** Similarity of modified to be eligible rename source (default 50) */

uint16_t rename_from_rewrite_threshold;

/** Similarity to consider a file a copy (default 50) */

uint16_t copy_threshold;

/** Similarity to split modify into delete/add pair (default 60) */

uint16_t break_rewrite_threshold;

/** Maximum similarity sources to examine for a file (somewhat like

size_t rename_limit;

/** Pluggable similarity metric; pass NULL to use internal metric */

git_diff_similarity_metric *metric;

} git_diff_find_options;

#define GIT_DIFF_FIND_OPTIONS_VERSION 1

#define GIT_DIFF_FIND_OPTIONS_INIT {GIT_DIFF_FIND_OPTIONS_VERSION}

GIT_EXTERN(int) git_diff_find_init_options(

git_diff_find_options *opts,

unsigned int version);

GIT_EXTERN(void) git_diff_free(git_diff *diff);

GIT_EXTERN(int) git_diff_tree_to_tree(

const git_diff_options *opts); /**< can be NULL for defaults */

GIT_EXTERN(int) git_diff_tree_to_index(

const git_diff_options *opts); /**< can be NULL for defaults */

GIT_EXTERN(int) git_diff_index_to_workdir(

const git_diff_options *opts); /**< can be NULL for defaults */

GIT_EXTERN(int) git_diff_tree_to_workdir(

const git_diff_options *opts); /**< can be NULL for defaults */

GIT_EXTERN(int) git_diff_tree_to_workdir_with_index(

const git_diff_options *opts); /**< can be NULL for defaults */

GIT_EXTERN(int) git_diff_index_to_index(

const git_diff_options *opts); /**< can be NULL for defaults */

GIT_EXTERN(int) git_diff_merge(

git_diff *onto,

const git_diff *from);

GIT_EXTERN(int) git_diff_find_similar(

git_diff *diff,

const git_diff_find_options *options);

GIT_EXTERN(size_t) git_diff_num_deltas(const git_diff *diff);

GIT_EXTERN(size_t) git_diff_num_deltas_of_type(

const git_diff *diff, git_delta_t type);

GIT_EXTERN(const git_diff_delta *) git_diff_get_delta(

const git_diff *diff, size_t idx);

GIT_EXTERN(int) git_diff_is_sorted_icase(const git_diff *diff);