#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 = (1 << 0),

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

GIT_DIFF_FORCE_TEXT = (1 << 1),

/** Ignore all whitespace */

GIT_DIFF_IGNORE_WHITESPACE = (1 << 2),

/** Ignore changes in amount of whitespace */

GIT_DIFF_IGNORE_WHITESPACE_CHANGE = (1 << 3),

/** Ignore whitespace at end of line */

GIT_DIFF_IGNORE_WHITESPACE_EOL = (1 << 4),

/** Exclude submodules from the diff completely */

GIT_DIFF_IGNORE_SUBMODULES = (1 << 5),

/** Use the "patience diff" algorithm (currently unimplemented) */

GIT_DIFF_PATIENCE = (1 << 6),

/** Include ignored files in the diff list */

GIT_DIFF_INCLUDE_IGNORED = (1 << 7),

/** Include untracked files in the diff list */

GIT_DIFF_INCLUDE_UNTRACKED = (1 << 8),

/** Include unmodified files in the diff list */

GIT_DIFF_INCLUDE_UNMODIFIED = (1 << 9),

/** Even with GIT_DIFF_INCLUDE_UNTRACKED, an entire untracked directory

GIT_DIFF_RECURSE_UNTRACKED_DIRS = (1 << 10),

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

GIT_DIFF_DISABLE_PATHSPEC_MATCH = (1 << 11),

/** Use case insensitive filename comparisons */

GIT_DIFF_DELTAS_ARE_ICASE = (1 << 12),

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

GIT_DIFF_INCLUDE_UNTRACKED_CONTENT = (1 << 13),

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

GIT_DIFF_SKIP_BINARY_CHECK = (1 << 14),

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

GIT_DIFF_INCLUDE_TYPECHANGE = (1 << 15),

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

GIT_DIFF_INCLUDE_TYPECHANGE_TREES = (1 << 16),

/** Ignore file mode changes */

GIT_DIFF_IGNORE_FILEMODE = (1 << 17),

/** Even with GIT_DIFF_INCLUDE_IGNORED, an entire ignored directory

GIT_DIFF_RECURSE_IGNORED_DIRS = (1 << 18),

} git_diff_option_t;

typedef struct git_diff_list git_diff_list;

typedef enum {

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

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

GIT_DIFF_FLAG_VALID_OID = (1 << 2), /** `oid` value is known correct */

} 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_t;

typedef struct {

git_oid oid;

const char *path;

git_off_t size;

uint32_t flags;

uint16_t mode;

} git_diff_file;

typedef struct {

git_diff_file old_file;

git_diff_file new_file;

git_delta_t status;

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

uint32_t flags;

} git_diff_delta;

typedef int (*git_diff_notify_cb)(

const git_diff_list *diff_so_far,

const git_diff_delta *delta_to_add,

const char *matched_pathspec,

void *payload);

typedef struct {

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

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

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

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

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

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

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

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

git_diff_notify_cb notify_cb;

void *notify_payload;

} git_diff_options;

#define GIT_DIFF_OPTIONS_VERSION 1

#define GIT_DIFF_OPTIONS_INIT {GIT_DIFF_OPTIONS_VERSION, GIT_DIFF_NORMAL, 3}

typedef int (*git_diff_file_cb)(

const git_diff_delta *delta,

float progress,

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 */

} git_diff_range;

typedef int (*git_diff_hunk_cb)(

const git_diff_delta *delta,

const git_diff_range *range,

const char *header,

size_t header_len,

void *payload);

typedef enum {

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

GIT_DIFF_LINE_CONTEXT = ' ',

GIT_DIFF_LINE_ADDITION = '+',

GIT_DIFF_LINE_DELETION = '-',

GIT_DIFF_LINE_ADD_EOFNL = '\n', /**< Removed line w/o LF & added one with */

GIT_DIFF_LINE_DEL_EOFNL = '\0', /**< LF was removed at end of file */

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

GIT_DIFF_LINE_FILE_HDR = 'F',

GIT_DIFF_LINE_HUNK_HDR = 'H',

GIT_DIFF_LINE_BINARY = 'B'

} git_diff_line_t;

typedef int (*git_diff_data_cb)(

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

const git_diff_range *range, /** range of lines containing this data */

char line_origin, /** git_diff_list_t value from above */

const char *content, /** diff data - not NUL terminated */

size_t content_len, /** number of bytes of diff data */

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

typedef struct git_diff_patch git_diff_patch;

typedef enum {

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

GIT_DIFF_FIND_RENAMES = (1 << 0),

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

GIT_DIFF_FIND_RENAMES_FROM_REWRITES = (1 << 1),

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

GIT_DIFF_FIND_COPIES = (1 << 2),

/** consider unmodified as copy sources? (`--find-copies-harder`) */

GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED = (1 << 3),

/** split large rewrites into delete/add pairs (`--break-rewrites=/M`) */

GIT_DIFF_FIND_AND_BREAK_REWRITES = (1 << 4),

/** turn on all finding features */

GIT_DIFF_FIND_ALL = (0x1f),

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

GIT_DIFF_FIND_IGNORE_LEADING_WHITESPACE = 0,

/** measure similarity ignoring all whitespace */

GIT_DIFF_FIND_IGNORE_WHITESPACE = (1 << 6),

/** measure similarity including all data */

GIT_DIFF_FIND_DONT_IGNORE_WHITESPACE = (1 << 7),

} 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;

/** Combination of git_diff_find_t values (default FIND_RENAMES) */

unsigned int flags;

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

unsigned int rename_threshold;

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

unsigned int rename_from_rewrite_threshold;

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

unsigned int copy_threshold;

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

unsigned int break_rewrite_threshold;

/** Maximum similarity sources to examine (a la diff's `-l` option or

unsigned int target_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(void) git_diff_list_free(git_diff_list *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_merge(

git_diff_list *onto,

const git_diff_list *from);

GIT_EXTERN(int) git_diff_find_similar(

git_diff_list *diff,

git_diff_find_options *options);

GIT_EXTERN(int) git_diff_foreach(

void *payload);

GIT_EXTERN(int) git_diff_print_compact(

git_diff_list *diff,

git_diff_data_cb print_cb,

void *payload);

GIT_EXTERN(char) git_diff_status_char(git_delta_t status);

GIT_EXTERN(int) git_diff_print_patch(

git_diff_list *diff,

git_diff_data_cb print_cb,

void *payload);

GIT_EXTERN(size_t) git_diff_num_deltas(git_diff_list *diff);

GIT_EXTERN(size_t) git_diff_num_deltas_of_type(

git_diff_list *diff,

git_delta_t type);

GIT_EXTERN(int) git_diff_get_patch(

size_t idx);

GIT_EXTERN(void) git_diff_patch_free(

git_diff_patch *patch);

GIT_EXTERN(const git_diff_delta *) git_diff_patch_delta(

git_diff_patch *patch);

GIT_EXTERN(size_t) git_diff_patch_num_hunks(

git_diff_patch *patch);

GIT_EXTERN(int) git_diff_patch_line_stats(

const git_diff_patch *patch);

GIT_EXTERN(int) git_diff_patch_get_hunk(

size_t hunk_idx);

GIT_EXTERN(int) git_diff_patch_num_lines_in_hunk(

git_diff_patch *patch,

size_t hunk_idx);

GIT_EXTERN(int) git_diff_patch_get_line_in_hunk(

size_t line_of_hunk);

GIT_EXTERN(int) git_diff_patch_print(

git_diff_patch *patch,

git_diff_data_cb print_cb,

void *payload);

GIT_EXTERN(int) git_diff_patch_to_str(

char **string,

git_diff_patch *patch);

GIT_EXTERN(int) git_diff_blobs(

void *payload);

GIT_EXTERN(int) git_diff_blob_to_buffer(

void *payload);