import { ITGitRequestConfig } from '..';
import { ProjectId, IUser, IMilestone, IFileDiff, ICommit, IReviewer, IPerPageParams, INote } from '../base';

export interface IMergeRequest {
  id: number;
  title: string;
  target_project_id: number;
  target_branch: string;
  source_project_id: number;
  source_branch: string;
  merge_commit_sha?: string | null;
  state: string;
  iid: number;
  description: string;
  created_at: string;
  updated_at: string;
  labels: string[];
  assignee: {
    avatar_url: string;
    id: number;
    name: string;
    state: 'active' | 'inactive';
    username: string;
    web_url: string;
  } | null;
  author: IUser;
  milestone: IMilestone;
  necessary_reviewers: IReviewer[];
  suggestion_reviewers: IReviewer[];
  files?: IFileDiff[];
  project_id: number;
  work_in_progress: boolean;
  upvotes: number;
  downvotes: number;
  base_commit: string;
  source_commit: string;
  target_commit: string;
}

export interface IMergeRequestComment {
  id: number;
  body: string;
  attachment: null | any;
  author: IUser;
  created_at: string;
  system: boolean;
}

export interface IMergeConflictRes {
  has_conflicts: boolean;
  base_commit: string;
  target_commit: string;
  conflict_files: string[];
}

export interface IMergeRequests {
  (
    params: {
      id: ProjectId;
      iid?: number;
      iids?: number[];
      state?: 'opend' | 'opened' | 'merged' | 'closed';
      /** 排序字段， 允许按 created_at, updated_at 排序（默认 created_at） */
      order_by?: 'created_at' | 'updated_at';
      /** 排序方式， 允许 asc or desc（默认 desc） */
      sort?: 'asc' | 'desc';
      created_after?: string;
      created_before?: string;
      updated_after?: string;
      updated_before?: string;
      source_branch?: string;
      target_branch?: string;
    } & IPerPageParams,
    requestOptions?: ITGitRequestConfig,
  ): Promise<IMergeRequest[]>;
  changes: IMergeRequestsChanges;
  add: IMergeRequestsAdd;
  commits: IMergeRequestsCommits;
  review: IMergeRequestsReview;
  get: IMergeRequestGet;
  getByIid: IMergeRequestGetByIid;
  merge: IMergeRequestMerge;
  modify: IMergeRequestModify;
  comments: IMergeRequestComments;
  check: IMergeRequestCheck;
  merge_conflict_check: IMergeConflictCheck;
  notes: IMergeRequestsNotes;
  create_pre_merge_commit: IMergeRequestsPreMergeCommit;
  revert: IMergeRequestsRevert;
}

export enum MergeRequestsNotesRisk {
  DEFAULT = 0,
  SLIGHT = 1,
  NORMAL = 2,
  SERIOUS = 3,
}

export enum MergeRequestsNotesResolveState {
  DEFAULT = 0,
  UNRESOLVED = 1,
  RESOLVED = 2,
}

export interface IMergeRequestsNotes {
  (
    params: {
      id: ProjectId;
      merge_request_id: number;
      system?: boolean;
      sort?: 'created_asc' | 'created_desc';
      resolve_states?: MergeRequestsNotesResolveState[];
    } & IPerPageParams,
    requestOptions?: ITGitRequestConfig,
  ): Promise<INote[]>;
  add: IMergeRequestNotesAdd;
  modify: IMergeRequestNotesModify;
  get: IMergeRequestNotesGet;
}

export type IMergeRequestNotesAdd = (
  params: {
    id: ProjectId;
    merge_request_id: number;
    body: string;
    path?: string;
    line?: string;
    line_type?: 'old' | 'new';
    risk?: MergeRequestsNotesRisk;
    resolve_state?: MergeRequestsNotesResolveState;
    label_ids?: number[];
    is_person_note?: boolean;
    notify_enabled?: boolean;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<INote>;

export type IMergeRequestNotesModify = (
  params: {
    id: ProjectId;
    merge_request_id: number;
    body: string;
    note_id: number;
    risk?: MergeRequestsNotesRisk;
    resolve_state?: MergeRequestsNotesResolveState;
    label_ids?: number[];
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<INote>;

export type IMergeRequestNotesGet = (
  params: {
    id: ProjectId;
    merge_request_id: number;
    note_id: number;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<INote>;

export interface IMergeRequestComments {
  (
    params: {
      id: ProjectId;
      merge_request_id: number;
    } & IPerPageParams,
    requestOptions?: ITGitRequestConfig,
  ): Promise<IMergeRequestComment[]>;
  add: IMergeRequestCommentsAdd;
}

export interface IMergeRequestComments {
  (
    params: {
      id: ProjectId;
      merge_request_id: number;
    } & IPerPageParams,
  ): Promise<IMergeRequestComment[]>;
  add: IMergeRequestCommentsAdd;
  edit: IMergeRequestCommentsEdit;
}
export type IMergeRequestCommentsAdd = (
  params: {
    id: ProjectId;
    merge_request_id: number;
    note: string;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<IMergeRequestComment>;

export type IMergeRequestCheck = (
  params: {
    id: ProjectId;
    merge_request_id: number;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<IMergeRequest>;
export type IMergeConflictCheck = (
  params: {
    id: ProjectId;
    merge_request_id: number;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<IMergeConflictRes>;

export type IMergeRequestCommentsEdit = (
  params: {
    id: ProjectId;
    merge_request_id: number;
    note_id: number;
    body: string;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<IMergeRequestComment>;

export type IMergeRequestMerge = (
  params: {
    id: ProjectId;
    merge_request_id: number;
    merge_type?: 'merge' | 'squash' | 'rebase';
    merge_commit_message?: string;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<IMergeRequest>;

export type IMergeRequestModify = (
  params: {
    id: ProjectId;
    merge_request_id: number;
    target_branch?: string;
    assignee_id?: number;
    title?: string;
    state_event?: 'close' | 'reopen';
    description?: string;
    labels?: string;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<IMergeRequest>;

export type IMergeRequestGet = (
  params: {
    id: ProjectId;
    merge_request_id: number;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<IMergeRequest>;

export type IMergeRequestGetByIid = (
  params: {
    id: ProjectId;
    merge_request_iid: number;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<IMergeRequest>;

export type IMergeRequestsChanges = (
  params: {
    id: ProjectId;
    merge_request_id: number;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<IMergeRequest>;

export type IMergeRequestsAdd = (
  params: {
    id: ProjectId;
    source_branch: string;
    target_branch: string;
    title: string;
    assignee_id?: number;
    description?: string;
    target_project_id?: number;
    labels?: string;
    reviewers?: string;
    necessary_reviewers?: string;
    approver_rule?: number;
    necessary_approver_rule?: number;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<IMergeRequest>;

export type IMergeRequestsCommits = (
  params: {
    id: ProjectId;
    merge_request_id: number;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<ICommit[]>;

export type IMergeRequestsPreMergeCommit = (
  params: {
    id: ProjectId;
    merge_request_id: number;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<{
  id: string;
  message: string;
  parent_ids: Array<string>;
  authored_date: string;
  author_name: string;
  author_email: string;
  committed_date: string;
  committer_name: string;
  committer_email: string;
  title: string;
  created_at: string;
  short_id: string;
  conflict: boolean;
  conflict_files: Array<string>;
}>;

export type IMergeRequestsRevert = (
  params: {
    id: ProjectId;
    merge_request_id: number;
    target_branch: string;
    create_mr?: boolean;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<number>;

export interface IMergeRequestsReview {
  (
    params: {
      id: ProjectId;
      merge_request_id: number;
    },
    requestOptions?: ITGitRequestConfig,
  ): Promise<{
    author: IUser;
    reviewers: IReviewer[];
    id: number;
    project_id: number;
    reviewable_id: number;
    reviewable_type: string;
    commit_id: string | null;
    state: string;
    restrict_type: string;
    push_reset_enabled: boolean;
    created_at: string;
    updated_at: string;
  }>;
  invite: IMergeRequestsReviewInvite;
  dismissals: IMergeRequestsReviewDismissals;
  cancel: IMergeRequestsReviewCancel;
  summary: IMergeRequestsReviewSummary;
  reopen: IMergeRequestsReviewReopen;
}

export type IMergeRequestsReviewInvite = (
  params: {
    id: ProjectId;
    merge_request_id: number;
    reviewer_id?: number;
    necessary_reviewer_id?: number;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<{
  author: IUser;
  reviewers: IReviewer[];
  id: number;
  project_id: number;
  reviewable_id: number;
  reviewable_type: string;
  commit_id: string | null;
  state: string;
  restrict_type: string;
  push_reset_enabled: boolean;
  created_at: string;
  updated_at: string;
}>;

export type IMergeRequestsReviewDismissals = (
  params: {
    id: ProjectId;
    merge_request_id: number;
    reviewer_id: number;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<any>;

export type IMergeRequestsReviewCancel = (
  params: {
    id: ProjectId;
    merge_request_id: number;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<any>;

export type IMergeRequestsReviewSummary = (
  params: {
    id: ProjectId;
    merge_request_id: number;
    reviewer_event: 'comment' | 'approve' | 'require_change' | 'deny';
    summary: string;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<{
  author: IUser;
  reviewers: IReviewer[];
  id: number;
  project_id: number;
  reviewable_id: number;
  reviewable_type: string;
  commit_id: string | null;
  state: string;
  restrict_type: string;
  push_reset_enabled: boolean;
  created_at: string;
  updated_at: string;
}>;

export type IMergeRequestsReviewReopen = (
  params: {
    id: ProjectId;
    merge_request_id: number;
  },
  requestOptions?: ITGitRequestConfig,
) => Promise<{
  author: IUser;
  reviewers: IReviewer[];
  id: number;
  project_id: number;
  reviewable_id: number;
  reviewable_type: string;
  commit_id: string | null;
  state: string;
  restrict_type: string;
  push_reset_enabled: boolean;
  created_at: string;
  updated_at: string;
}>;