use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[repr(i64)]
pub enum AccessMode {
    None = 0,
    Read = 1,
    Write = 2,
    Admin = 3,
    Owner = 4,
}

impl AccessMode {
    pub fn parse_permission(permission: &str) -> Option<Self> {
        match permission.trim().to_ascii_lowercase().as_str() {
            "read" => Some(Self::Read),
            "write" => Some(Self::Write),
            "admin" => Some(Self::Admin),
            _ => None,
        }
    }
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[repr(i64)]
pub enum PullRequestStatus {
    Conflict = 0,
    Checking = 1,
    Mergeable = 2,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct User {
    pub id: i64,
    pub lower_name: String,
    pub name: String,
    pub full_name: String,
    pub email: String,
    pub password_hash: String,
    pub is_active: bool,
    pub is_admin: bool,
    pub created_unix: i64,
    pub updated_unix: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApiUser {
    pub id: i64,
    pub lower_name: String,
    pub name: String,
    pub full_name: String,
    pub email: String,
    pub created_unix: i64,
    pub updated_unix: i64,
}

#[derive(Debug, Deserialize)]
pub struct CreateUserRequest {
    pub username: String,
    pub email: String,
    pub password: String,
    #[serde(default)]
    pub full_name: String,
    #[serde(default)]
    pub is_admin: bool,
    #[serde(default = "default_true")]
    pub is_active: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Repository {
    pub id: i64,
    pub owner_id: i64,
    pub lower_name: String,
    pub name: String,
    pub description: String,
    pub default_branch: String,
    pub is_private: bool,
    pub is_bare: bool,
    pub is_fork: bool,
    pub fork_id: i64,
    pub created_unix: i64,
    pub updated_unix: i64,
}

#[derive(Debug, Deserialize)]
pub struct CreateRepositoryRequest {
    pub name: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub is_private: bool,
    #[serde(default)]
    pub auto_init: bool,
}

#[derive(Debug, Deserialize)]
pub struct ForkRepositoryRequest {
    pub name: String,
    #[serde(default)]
    pub description: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RepositoryWithOwner {
    pub repo: Repository,
    pub owner: User,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApiRepositoryWithOwner {
    pub repo: Repository,
    pub owner: ApiUser,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RepositoryPermission {
    pub mode: AccessMode,
    pub can_read: bool,
    pub can_write: bool,
    pub can_admin: bool,
    pub is_owner: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApiRepositoryResponse {
    pub repo: Repository,
    pub owner: ApiUser,
    pub permission: RepositoryPermission,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AccessToken {
    pub id: i64,
    pub user_id: i64,
    pub name: String,
    pub token_hash: String,
    pub created_unix: i64,
    pub updated_unix: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Collaboration {
    pub id: i64,
    pub user_id: i64,
    pub repo_id: i64,
    pub mode: AccessMode,
}

#[derive(Debug, Deserialize)]
pub struct LoginRequest {
    pub login: String,
    pub password: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LoginResponse {
    pub token: String,
    pub user: User,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ApiLoginResponse {
    pub token: String,
    pub user: ApiUser,
}

#[derive(Debug, Deserialize)]
pub struct CreateAccessTokenRequest {
    pub name: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CreateAccessTokenResponse {
    pub id: i64,
    pub name: String,
    pub token: String,
    pub created_unix: i64,
    pub updated_unix: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AccessTokenResponse {
    pub id: i64,
    pub name: String,
    pub created_unix: i64,
    pub updated_unix: i64,
}

#[derive(Debug, Deserialize)]
pub struct UpsertCollaboratorRequest {
    pub username: String,
    pub permission: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CollaboratorResponse {
    pub user: User,
    pub mode: AccessMode,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ApiCollaboratorResponse {
    pub user: ApiUser,
    pub mode: AccessMode,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Branch {
    pub name: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PullRequest {
    pub id: i64,
    pub index: i64,
    pub title: String,
    pub body: String,
    pub status: PullRequestStatus,
    pub head_repo_id: i64,
    pub base_repo_id: i64,
    pub head_user_name: String,
    pub head_branch: String,
    pub base_branch: String,
    pub merge_base: String,
    pub merged_commit_id: String,
    pub poster_id: i64,
    pub has_merged: bool,
    pub is_closed: bool,
    pub created_unix: i64,
    pub updated_unix: i64,
}

#[derive(Debug, Deserialize)]
pub struct CreatePullRequestRequest {
    pub head_owner: String,
    pub head_repo: String,
    pub head_branch: String,
    pub base_branch: String,
    pub title: String,
    #[serde(default)]
    pub body: String,
}

#[derive(Debug, Deserialize)]
pub struct MergePullRequestRequest {
    #[serde(default)]
    pub message: String,
}

#[derive(Debug, Deserialize)]
pub struct CompareRequest {
    pub base: String,
    pub head_owner: String,
    pub head_repo: String,
    pub head_branch: String,
}

#[derive(Debug, Deserialize)]
pub struct RepositoryListQuery {
    #[serde(default)]
    pub q: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompareCommit {
    pub id: String,
    pub summary: String,
    pub author_name: String,
    pub author_email: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompareFile {
    pub path: String,
    pub additions: i64,
    pub deletions: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompareResponse {
    pub base_branch: String,
    pub head_branch: String,
    pub merge_base: String,
    pub head_commit_id: String,
    pub status: PullRequestStatus,
    pub commits: Vec<CompareCommit>,
    pub files: Vec<CompareFile>,
    pub is_nothing_to_compare: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PullRequestResponse {
    pub pull_request: PullRequest,
    pub head_repo: RepositoryWithOwner,
    pub base_repo: RepositoryWithOwner,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApiPullRequestResponse {
    pub pull_request: PullRequest,
    pub head_repo: ApiRepositoryWithOwner,
    pub base_repo: ApiRepositoryWithOwner,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PullRequestDetailResponse {
    pub pull_request: PullRequest,
    pub head_repo: RepositoryWithOwner,
    pub base_repo: RepositoryWithOwner,
    pub compare: CompareResponse,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApiPullRequestDetailResponse {
    pub pull_request: PullRequest,
    pub head_repo: ApiRepositoryWithOwner,
    pub base_repo: ApiRepositoryWithOwner,
    pub compare: CompareResponse,
}

fn default_true() -> bool {
    true
}

impl From<&User> for ApiUser {
    fn from(value: &User) -> Self {
        Self {
            id: value.id,
            lower_name: value.lower_name.clone(),
            name: value.name.clone(),
            full_name: value.full_name.clone(),
            email: value.email.clone(),
            created_unix: value.created_unix,
            updated_unix: value.updated_unix,
        }
    }
}

impl From<&RepositoryWithOwner> for ApiRepositoryWithOwner {
    fn from(value: &RepositoryWithOwner) -> Self {
        Self {
            repo: value.repo.clone(),
            owner: ApiUser::from(&value.owner),
        }
    }
}

impl ApiRepositoryResponse {
    pub fn from_repo(value: &RepositoryWithOwner, permission: RepositoryPermission) -> Self {
        Self {
            repo: value.repo.clone(),
            owner: ApiUser::from(&value.owner),
            permission,
        }
    }
}

impl From<&LoginResponse> for ApiLoginResponse {
    fn from(value: &LoginResponse) -> Self {
        Self {
            token: value.token.clone(),
            user: ApiUser::from(&value.user),
        }
    }
}

impl From<&CollaboratorResponse> for ApiCollaboratorResponse {
    fn from(value: &CollaboratorResponse) -> Self {
        Self {
            user: ApiUser::from(&value.user),
            mode: value.mode,
        }
    }
}

impl From<&PullRequestResponse> for ApiPullRequestResponse {
    fn from(value: &PullRequestResponse) -> Self {
        Self {
            pull_request: value.pull_request.clone(),
            head_repo: ApiRepositoryWithOwner::from(&value.head_repo),
            base_repo: ApiRepositoryWithOwner::from(&value.base_repo),
        }
    }
}

impl From<&PullRequestDetailResponse> for ApiPullRequestDetailResponse {
    fn from(value: &PullRequestDetailResponse) -> Self {
        Self {
            pull_request: value.pull_request.clone(),
            head_repo: ApiRepositoryWithOwner::from(&value.head_repo),
            base_repo: ApiRepositoryWithOwner::from(&value.base_repo),
            compare: value.compare.clone(),
        }
    }
}