package git2_bindings

import "core:c"

Error :: struct {
	message: cstring,
	klass:   Klass,
}

Klass :: enum c.int {
	None       = 0,
	Nomemory   = 1,
	Os         = 2,
	Invalid    = 3,
	Reference  = 4,
	Zlib       = 5,
	Repository = 6,
	Config     = 7,
	Regex      = 8,
	Odb        = 9,
	Index      = 10,
	Object     = 11,
	Net        = 12,
	Tag        = 13,
	Tree       = 14,
	Indexer    = 15,
	Ssl        = 16,
	Submodule  = 17,
	Thread     = 18,
	Stash      = 19,
	Checkout   = 20,
	Fetchhead  = 21,
	Merge      = 22,
	Ssh        = 23,
	Filter     = 24,
	Revert     = 25,
	Callback   = 26,
	Cherrypick = 27,
	Describe   = 28,
	Rebase     = 29,
	Filesystem = 30,
	Patch      = 31,
	Worktree   = 32,
	Sha        = 33,
	Http       = 34,
	Internal   = 35,
	Grafts     = 36,
}

Result :: enum c.int {
	Ok              = 0,
	Error           = -1,
	Enotfound       = -3,
	Eexists         = -4,
	Eambiguous      = -5,
	Ebufs           = -6,
	Euser           = -7,
	Ebarerepo       = -8,
	Eunbornbranch   = -9,
	Eunmerged       = -10,
	Enonfastforward = -11,
	Einvalidspec    = -12,
	Econflict       = -13,
	Elocked         = -14,
	Emodified       = -15,
	Eauth           = -16,
	Ecertificate    = -17,
	Eapplied        = -18,
	Epeel           = -19,
	Eeof            = -20,
	Einvalid        = -21,
	Euncommitted    = -22,
	Edirectory      = -23,
	Emergeconflict  = -24,
	Passthrough     = -30,
	Iterover        = -31,
	Retry           = -32,
	Emismatch       = -33,
	Eindexdirty     = -34,
	Eapplyfail      = -35,
	Eowner          = -36,
	Timeout         = -37,
	Eunchanged      = -38,
	Enotsupported   = -39,
	Ereadonly       = -40,
}

Repository :: distinct rawptr
Reference :: distinct rawptr
Reference_Iterator :: distinct rawptr
Blob :: distinct rawptr
Tree_Entry :: distinct rawptr
Tree_Builder :: distinct rawptr
Config :: distinct rawptr
Config_Iterator :: distinct rawptr
Index :: distinct rawptr
Index_Iterator :: distinct rawptr
Index_Conflict_Iterator :: distinct rawptr
Revwalk :: distinct rawptr
Remote :: distinct rawptr
Reflog :: distinct rawptr
Reflog_Entry :: distinct rawptr
Branch_Iterator :: distinct rawptr
Annotated_Commit :: distinct rawptr
Status_List :: distinct rawptr
Diff :: distinct rawptr
Diff_Stats :: distinct rawptr
Patch :: distinct rawptr
Blame :: distinct rawptr
Odb :: distinct rawptr
Odb_Object :: distinct rawptr
Note :: distinct rawptr
Note_Iterator :: distinct rawptr
Packbuilder :: distinct rawptr
Transaction :: distinct rawptr
Worktree :: distinct rawptr
Mailmap :: distinct rawptr
Submodule :: distinct rawptr
Rebase :: distinct rawptr
Oid_Shorten :: distinct rawptr

Object :: distinct rawptr
Commit :: Object
Tree :: Object
Tag :: Object

Oid :: struct {
	id: [20]u8,
}

Signature_Time :: struct {
	time:   Time,
	offset: c.int,
	sign:   u8,
}

Time :: c.int64_t

Signature :: struct {
	name:     cstring,
	email:    cstring,
	sig_when: Signature_Time,
}

Object_Type :: enum c.int {
	Any       = -2,
	Invalid   = -1,
	Commit    = 1,
	Tree      = 2,
	Blob      = 3,
	Tag       = 4,
	Ofs_Delta = 6,
	Ref_Delta = 7,
}

Reference_Type :: enum c.int {
	Invalid  = 0,
	Direct   = 1,
	Symbolic = 2,
	All      = 3,
}

Branch_Type :: enum c.int {
	Local  = 1,
	Remote = 2,
	All    = 3,
}

Filemode :: enum c.int {
	Unreadable      = 0o000000,
	Tree            = 0o040000,
	Blob            = 0o100644,
	Blob_Executable = 0o100755,
	Link            = 0o120000,
	Commit          = 0o160000,
}

Buf :: struct {
	ptr:      [^]u8,
	reserved: c.size_t,
	size:     c.size_t,
}

Strarray :: struct {
	strings: [^]cstring,
	count:   c.size_t,
}

Oidarray :: struct {
	ids:   [^]Oid,
	count: c.size_t,
}

Index_Time :: struct {
	seconds:     c.int32_t,
	nanoseconds: c.uint32_t,
}

Index_Entry :: struct {
	ctime:          Index_Time,
	mtime:          Index_Time,
	dev:            c.uint32_t,
	ino:            c.uint32_t,
	mode:           c.uint32_t,
	uid:            c.uint32_t,
	gid:            c.uint32_t,
	file_size:      c.uint32_t,
	id:             Oid,
	flags:          c.uint16_t,
	flags_extended: c.uint16_t,
	path:           cstring,
}

// --- Diff types ---

Delta_Type :: enum c.int {
	Unmodified = 0,
	Added      = 1,
	Deleted    = 2,
	Modified   = 3,
	Renamed    = 4,
	Copied     = 5,
	Ignored    = 6,
	Untracked  = 7,
	Typechange = 8,
	Unreadable = 9,
	Conflicted = 10,
}

Diff_Flag :: enum c.uint32_t {
	Binary     = 0,
	Not_Binary = 1,
	Valid_Id   = 2,
	Exists     = 3,
	Valid_Size = 4,
}
Diff_Flags :: distinct bit_set[Diff_Flag;c.uint32_t]

Diff_File :: struct {
	id:        Oid,
	path:      cstring,
	size:      c.uint64_t,
	flags:     c.uint32_t,
	mode:      c.uint16_t,
	id_abbrev: c.uint16_t,
}

Diff_Delta :: struct {
	status:     Delta_Type,
	flags:      c.uint32_t,
	similarity: c.uint16_t,
	nfiles:     c.uint16_t,
	old_file:   Diff_File,
	new_file:   Diff_File,
}

Diff_Hunk :: struct {
	old_start:  c.int,
	old_lines:  c.int,
	new_start:  c.int,
	new_lines:  c.int,
	header_len: c.size_t,
	header:     [128]u8,
}

Diff_Line :: struct {
	origin:         u8,
	old_lineno:     c.int,
	new_lineno:     c.int,
	num_lines:      c.int,
	content_len:    c.size_t,
	content_offset: c.int64_t,
	content:        [^]u8,
}

Diff_Format :: enum c.int {
	Patch        = 1,
	Patch_Header = 2,
	Raw          = 3,
	Name_Only    = 4,
	Name_Status  = 5,
	Patch_Id     = 6,
}

Diff_Stats_Format :: enum c.uint {
	None            = 0,
	Full            = 1,
	Short           = 2,
	Number          = 4,
	Include_Summary = 8,
}

Status_Flags :: distinct c.uint

STATUS_CURRENT: Status_Flags : 0
STATUS_INDEX_NEW: Status_Flags : (1 << 0)
STATUS_INDEX_MODIFIED: Status_Flags : (1 << 1)
STATUS_INDEX_DELETED: Status_Flags : (1 << 2)
STATUS_INDEX_RENAMED: Status_Flags : (1 << 3)
STATUS_INDEX_TYPECHANGE: Status_Flags : (1 << 4)
STATUS_WT_NEW: Status_Flags : (1 << 7)
STATUS_WT_MODIFIED: Status_Flags : (1 << 8)
STATUS_WT_DELETED: Status_Flags : (1 << 9)
STATUS_WT_TYPECHANGE: Status_Flags : (1 << 10)
STATUS_WT_RENAMED: Status_Flags : (1 << 11)
STATUS_WT_UNREADABLE: Status_Flags : (1 << 12)
STATUS_IGNORED: Status_Flags : (1 << 14)
STATUS_CONFLICTED: Status_Flags : (1 << 15)

Status_Show :: enum c.int {
	Index_And_Workdir = 0,
	Index_Only        = 1,
	Workdir_Only      = 2,
}

Status_Options :: struct {
	version:          c.uint,
	show:             Status_Show,
	flags:            c.uint,
	pathspec:         Strarray,
	baseline:         Tree,
	rename_threshold: c.uint16_t,
}

Status_Entry :: struct {
	status:           Status_Flags,
	head_to_index:    ^Diff_Delta,
	index_to_workdir: ^Diff_Delta,
}

Sort_Flags :: distinct c.uint

SORT_NONE: Sort_Flags : 0
SORT_TOPOLOGICAL: Sort_Flags : (1 << 0)
SORT_TIME: Sort_Flags : (1 << 1)
SORT_REVERSE: Sort_Flags : (1 << 2)

Checkout_Strategy :: distinct c.uint

CHECKOUT_NONE: Checkout_Strategy : 0
CHECKOUT_SAFE: Checkout_Strategy : (1 << 0)
CHECKOUT_FORCE: Checkout_Strategy : (1 << 1)
CHECKOUT_RECREATE_MISSING: Checkout_Strategy : (1 << 2)
CHECKOUT_ALLOW_CONFLICTS: Checkout_Strategy : (1 << 3)
CHECKOUT_REMOVE_UNTRACKED: Checkout_Strategy : (1 << 4)
CHECKOUT_REMOVE_IGNORED: Checkout_Strategy : (1 << 5)
CHECKOUT_UPDATE_ONLY: Checkout_Strategy : (1 << 6)
CHECKOUT_DONT_UPDATE_INDEX: Checkout_Strategy : (1 << 7)
CHECKOUT_NO_REFRESH: Checkout_Strategy : (1 << 8)
CHECKOUT_SKIP_UNMERGED: Checkout_Strategy : (1 << 9)
CHECKOUT_USE_OURS: Checkout_Strategy : (1 << 10)
CHECKOUT_USE_THEIRS: Checkout_Strategy : (1 << 11)
CHECKOUT_DISABLE_PATHSPEC_MATCH: Checkout_Strategy : (1 << 12)
CHECKOUT_SKIP_LOCKED_DIRECTORIES: Checkout_Strategy : (1 << 18)
CHECKOUT_DONT_OVERWRITE_IGNORED: Checkout_Strategy : (1 << 19)
CHECKOUT_CONFLICT_STYLE_MERGE: Checkout_Strategy : (1 << 20)
CHECKOUT_CONFLICT_STYLE_DIFF3: Checkout_Strategy : (1 << 21)
CHECKOUT_DONT_REMOVE_EXISTING: Checkout_Strategy : (1 << 22)
CHECKOUT_DONT_WRITE_INDEX: Checkout_Strategy : (1 << 23)
CHECKOUT_DRY_RUN: Checkout_Strategy : (1 << 24)
CHECKOUT_CONFLICT_STYLE_ZDIFF3: Checkout_Strategy : (1 << 25)

Checkout_Options :: struct {
	version:           c.uint,
	checkout_strategy: Checkout_Strategy,
	disable_filters:   c.int,
	dir_mode:          c.uint,
	file_mode:         c.uint,
	file_open_flags:   c.int,
	notify_flags:      c.uint,
	notify_cb:         rawptr,
	notify_payload:    rawptr,
	progress_cb:       rawptr,
	progress_payload:  rawptr,
	paths:             Strarray,
	baseline:          Tree,
	baseline_index:    Index,
	target_directory:  cstring,
	ancestor_label:    cstring,
	our_label:         cstring,
	their_label:       cstring,
	perfdata_cb:       rawptr,
	perfdata_payload:  rawptr,
}

Merge_Analysis :: enum c.int {
	None        = 0,
	Normal      = 1,
	Up_To_Date  = 2,
	Fastforward = 4,
	Unborn      = 8,
}

Merge_Preference :: enum c.int {
	None             = 0,
	No_Fastforward   = 1,
	Fastforward_Only = 2,
}

Clone_Local :: enum c.int {
	Auto     = 0,
	Local    = 1,
	No_Local = 2,
	No_Links = 3,
}

Submodule_Update :: enum c.int {
	Checkout = 1,
	Rebase   = 2,
	Merge    = 3,
	None     = 4,
	Default  = 0,
}

Submodule_Ignore :: enum c.int {
	Unspecified = -1,
	None        = 1,
	Untracked   = 2,
	Dirty       = 3,
	All         = 4,
}

Submodule_Recurse :: enum c.int {
	No       = 0,
	Yes      = 1,
	Ondemand = 2,
}

Reset_Type :: enum c.int {
	Soft  = 1,
	Mixed = 2,
	Hard  = 3,
}

Stash_Flags :: distinct c.uint

STASH_DEFAULT: Stash_Flags : 0
STASH_KEEP_INDEX: Stash_Flags : (1 << 0)
STASH_INCLUDE_UNTRACKED: Stash_Flags : (1 << 1)
STASH_INCLUDE_IGNORED: Stash_Flags : (1 << 2)
STASH_KEEP_ALL: Stash_Flags : (1 << 3)

Blame_Hunk :: struct {
	lines_in_hunk:           c.size_t,
	final_commit_id:         Oid,
	final_start_line_number: c.size_t,
	final_signature:         ^Signature,
	final_committer:         ^Signature,
	orig_commit_id:          Oid,
	orig_path:               cstring,
	orig_start_line_number:  c.size_t,
	orig_signature:          ^Signature,
	orig_committer:          ^Signature,
	boundary:                u8,
}

Describe_Strategy :: enum c.uint {
	Default = 0,
	Tags    = 1,
	All     = 2,
}

Repository_State :: enum c.int {
	None                    = 0,
	Merge                   = 1,
	Revert                  = 2,
	Revert_Sequence         = 3,
	Cherrypick              = 4,
	Cherrypick_Sequence     = 5,
	Bisect                  = 6,
	Rebase                  = 7,
	Rebase_Interactive      = 8,
	Rebase_Merge            = 9,
	Apply_Mailbox           = 10,
	Apply_Mailbox_Or_Rebase = 11,
}

Reference_Foreach_Name_Cb :: #type proc "c" (name: cstring, payload: rawptr) -> c.int
Status_Cb :: #type proc "c" (path: cstring, status_flags: Status_Flags, payload: rawptr) -> c.int
Diff_File_Cb :: #type proc "c" (delta: ^Diff_Delta, progress: c.float, payload: rawptr) -> c.int
Diff_Binary_Cb :: #type proc "c" (delta: ^Diff_Delta, binary: rawptr, payload: rawptr) -> c.int
Diff_Hunk_Cb :: #type proc "c" (delta: ^Diff_Delta, hunk: ^Diff_Hunk, payload: rawptr) -> c.int
Diff_Line_Cb :: #type proc "c" (delta: ^Diff_Delta, hunk: ^Diff_Hunk, line: ^Diff_Line, payload: rawptr) -> c.int
Stash_Cb :: #type proc "c" (index: c.size_t, message: cstring, stash_id: ^Oid, payload: rawptr) -> c.int
Tag_Foreach_Cb :: #type proc "c" (name: cstring, oid: ^Oid, payload: rawptr) -> c.int
Fetchhead_Foreach_Cb :: #type proc "c" (
	ref_name: cstring,
	remote_url: cstring,
	oid: ^Oid,
	is_merge: c.uint,
	payload: rawptr,
) -> c.int
Mergehead_Foreach_Cb :: #type proc "c" (oid: ^Oid, payload: rawptr) -> c.int
Note_Foreach_Cb :: #type proc "c" (blob_id: ^Oid, annotated_object_id: ^Oid, payload: rawptr) -> c.int
Revwalk_Hide_Cb :: #type proc "c" (commit_id: ^Oid, payload: rawptr) -> c.int