use crate::{cmd::oid::ObjectId, rpc::proto as p};

impl From<ObjectId> for p::ObjectId {
    fn from(oid: ObjectId) -> Self {
        p::ObjectId { value: oid.0 }
    }
}

impl From<p::ObjectId> for ObjectId {
    fn from(oid: p::ObjectId) -> Self {
        ObjectId::new(&oid.value)
    }
}

impl From<&ObjectId> for p::ObjectId {
    fn from(oid: &ObjectId) -> Self {
        p::ObjectId {
            value: oid.0.clone(),
        }
    }
}

impl From<crate::cmd::commit::CommitSignature> for p::CommitSignature {
    fn from(sig: crate::cmd::commit::CommitSignature) -> Self {
        p::CommitSignature {
            name: sig.name,
            email: sig.email,
            time_secs: sig.time_secs,
            offset_minutes: sig.offset_minutes,
        }
    }
}

impl From<p::CommitSignature> for crate::cmd::commit::CommitSignature {
    fn from(sig: p::CommitSignature) -> Self {
        crate::cmd::commit::CommitSignature {
            name: sig.name,
            email: sig.email,
            time_secs: sig.time_secs,
            offset_minutes: sig.offset_minutes,
        }
    }
}

impl From<crate::cmd::tagger::GitTagger> for p::GitTagger {
    fn from(t: crate::cmd::tagger::GitTagger) -> Self {
        p::GitTagger {
            name: t.name,
            email: t.email,
        }
    }
}

impl From<p::GitTagger> for crate::cmd::tagger::GitTagger {
    fn from(t: p::GitTagger) -> Self {
        crate::cmd::tagger::GitTagger {
            name: t.name,
            email: t.email,
        }
    }
}

impl From<crate::cmd::commit::CommitMeta> for p::CommitMeta {
    fn from(c: crate::cmd::commit::CommitMeta) -> Self {
        p::CommitMeta {
            oid: Some(c.oid.into()),
            message: c.message,
            summary: c.summary,
            author: Some(c.author.into()),
            committer: Some(c.committer.into()),
            tree_id: Some(c.tree_id.into()),
            parent_ids: c.parent_ids.into_iter().map(Into::into).collect(),
            encoding: c.encoding,
        }
    }
}

impl From<crate::cmd::commit::CommitRefInfo> for p::CommitRefInfo {
    fn from(r: crate::cmd::commit::CommitRefInfo) -> Self {
        p::CommitRefInfo {
            name: r.name,
            target: Some(r.target.into()),
            is_remote: r.is_remote,
            is_tag: r.is_tag,
        }
    }
}

impl From<crate::cmd::commit::CommitSummary> for p::CommitSummary {
    fn from(s: crate::cmd::commit::CommitSummary) -> Self {
        p::CommitSummary {
            head: s.head.map(Into::into),
            count: s.count as u64,
        }
    }
}

impl From<crate::cmd::commit::CommitWalkSort> for p::CommitWalkSort {
    fn from(s: crate::cmd::commit::CommitWalkSort) -> Self {
        match s {
            crate::cmd::commit::CommitWalkSort::None => p::CommitWalkSort::None,
            crate::cmd::commit::CommitWalkSort::Topological => {
                p::CommitWalkSort::Topological
            }
            crate::cmd::commit::CommitWalkSort::Time => p::CommitWalkSort::Time,
            crate::cmd::commit::CommitWalkSort::Reverse => {
                p::CommitWalkSort::Reverse
            }
        }
    }
}

impl From<p::CommitWalkSort> for crate::cmd::commit::CommitWalkSort {
    fn from(s: p::CommitWalkSort) -> Self {
        match s {
            p::CommitWalkSort::None => crate::cmd::commit::CommitWalkSort::None,
            p::CommitWalkSort::Topological => {
                crate::cmd::commit::CommitWalkSort::Topological
            }
            p::CommitWalkSort::Time => crate::cmd::commit::CommitWalkSort::Time,
            p::CommitWalkSort::Reverse => {
                crate::cmd::commit::CommitWalkSort::Reverse
            }
        }
    }
}

impl From<i32> for crate::cmd::commit::CommitWalkSort {
    fn from(val: i32) -> Self {
        let proto_sort: p::CommitWalkSort =
            p::CommitWalkSort::try_from(val).unwrap_or(p::CommitWalkSort::Time);
        proto_sort.into()
    }
}

impl From<p::CommitWalkParams> for crate::cmd::commit::CommitWalkParams {
    fn from(p: p::CommitWalkParams) -> Self {
        crate::cmd::commit::CommitWalkParams {
            start_oids: p.start_oids.into_iter().map(Into::into).collect(),
            hide_oids: p.hide_oids.into_iter().map(Into::into).collect(),
            limit: p.limit.map(|l| l as usize),
            skip: p.skip as usize,
            first_parent: p.first_parent,
            sort: p.sort.into(),
            branch: None,
        }
    }
}

impl From<p::CommitCherryPickParams>
    for crate::cmd::commit::CommitCherryPickParams
{
    fn from(p: p::CommitCherryPickParams) -> Self {
        crate::cmd::commit::CommitCherryPickParams {
            cherrypick_oid: p.cherrypick_oid.unwrap_or_default().into(),
            author: p.author.unwrap_or_default().into(),
            committer: p.committer.unwrap_or_default().into(),
            message: p.message,
            mainline: p.mainline,
            update_ref: p.update_ref,
        }
    }
}

impl From<p::CommitCherryPickSequence>
    for crate::cmd::commit::CommitCherryPickSequence
{
    fn from(p: p::CommitCherryPickSequence) -> Self {
        crate::cmd::commit::CommitCherryPickSequence {
            cherrypick_oids: p
                .cherrypick_oids
                .into_iter()
                .map(Into::into)
                .collect(),
            author: p.author.unwrap_or_default().into(),
            committer: p.committer.unwrap_or_default().into(),
            update_ref: p.update_ref,
        }
    }
}

impl From<crate::cmd::branch::BranchListItem> for p::BranchListItem {
    fn from(b: crate::cmd::branch::BranchListItem) -> Self {
        p::BranchListItem {
            name: b.name,
            oid: Some(b.oid.into()),
            is_head: b.is_head,
            is_remote: b.is_remote,
            is_current: b.is_current,
            upstream: b.upstream,
        }
    }
}

impl From<crate::cmd::branch::BranchSummary> for p::BranchSummary {
    fn from(s: crate::cmd::branch::BranchSummary) -> Self {
        p::BranchSummary {
            local_count: s.local_count as u64,
            remote_count: s.remote_count as u64,
            all_count: s.all_count as u64,
        }
    }
}

impl From<p::BranchForkParams> for crate::cmd::branch::BranchForkParams {
    fn from(p: p::BranchForkParams) -> Self {
        crate::cmd::branch::BranchForkParams {
            name: p.name,
            oid: p.oid.unwrap_or_default().into(),
            force: p.force,
        }
    }
}

impl From<p::BranchDeleteParams> for crate::cmd::branch::BranchDeleteParams {
    fn from(p: p::BranchDeleteParams) -> Self {
        crate::cmd::branch::BranchDeleteParams {
            name: p.name,
            force: p.force,
        }
    }
}

impl From<p::BranchReNameParams> for crate::cmd::branch::BranchReNameParams {
    fn from(p: p::BranchReNameParams) -> Self {
        crate::cmd::branch::BranchReNameParams {
            old_branch: p.old_branch,
            new_branch: p.new_branch,
            force: p.force,
        }
    }
}

impl From<crate::cmd::diff::DiffDeltaStatus> for p::DiffDeltaStatus {
    fn from(s: crate::cmd::diff::DiffDeltaStatus) -> Self {
        match s {
            crate::cmd::diff::DiffDeltaStatus::Unmodified => {
                p::DiffDeltaStatus::Unmodified
            }
            crate::cmd::diff::DiffDeltaStatus::Added => {
                p::DiffDeltaStatus::Added
            }
            crate::cmd::diff::DiffDeltaStatus::Deleted => {
                p::DiffDeltaStatus::Deleted
            }
            crate::cmd::diff::DiffDeltaStatus::Modified => {
                p::DiffDeltaStatus::Modified
            }
            crate::cmd::diff::DiffDeltaStatus::Renamed => {
                p::DiffDeltaStatus::Renamed
            }
            crate::cmd::diff::DiffDeltaStatus::Copied => {
                p::DiffDeltaStatus::Copied
            }
            crate::cmd::diff::DiffDeltaStatus::Typechange => {
                p::DiffDeltaStatus::Typechange
            }
            crate::cmd::diff::DiffDeltaStatus::Conflicted => {
                p::DiffDeltaStatus::Conflicted
            }
        }
    }
}

impl From<crate::cmd::diff::DiffFile> for p::DiffFile {
    fn from(f: crate::cmd::diff::DiffFile) -> Self {
        p::DiffFile {
            oid: f.oid.map(Into::into),
            path: f.path,
            size: f.size,
            is_binary: f.is_binary,
        }
    }
}

impl From<crate::cmd::diff::DiffHunk> for p::DiffHunk {
    fn from(h: crate::cmd::diff::DiffHunk) -> Self {
        p::DiffHunk {
            old_start: h.old_start,
            old_lines: h.old_lines,
            new_start: h.new_start,
            new_lines: h.new_lines,
            header: h.header,
        }
    }
}

impl From<crate::cmd::diff::DiffLine> for p::DiffLine {
    fn from(l: crate::cmd::diff::DiffLine) -> Self {
        p::DiffLine {
            content: l.content,
            origin: l.origin.to_string(),
            old_lineno: l.old_lineno,
            new_lineno: l.new_lineno,
            num_lines: l.num_lines,
            content_offset: l.content_offset,
        }
    }
}

impl From<crate::cmd::diff::DiffDelta> for p::DiffDelta {
    fn from(d: crate::cmd::diff::DiffDelta) -> Self {
        let status_proto: p::DiffDeltaStatus = d.status.into();
        p::DiffDelta {
            status: status_proto as i32,
            old_file: Some(d.old_file.into()),
            new_file: Some(d.new_file.into()),
            nfiles: d.nfiles as u32,
            hunks: d.hunks.into_iter().map(Into::into).collect(),
            lines: d.lines.into_iter().map(Into::into).collect(),
        }
    }
}

impl From<crate::cmd::diff::DiffStats> for p::DiffStats {
    fn from(s: crate::cmd::diff::DiffStats) -> Self {
        p::DiffStats {
            files_changed: s.files_changed as u64,
            insertions: s.insertions as u64,
            deletions: s.deletions as u64,
        }
    }
}

impl From<crate::cmd::diff::DiffResult> for p::DiffResult {
    fn from(r: crate::cmd::diff::DiffResult) -> Self {
        p::DiffResult {
            stats: Some(r.stats.into()),
            deltas: r.deltas.into_iter().map(Into::into).collect(),
        }
    }
}

impl From<p::DiffOptions> for crate::cmd::diff::DiffOptions {
    fn from(o: p::DiffOptions) -> Self {
        crate::cmd::diff::DiffOptions {
            context_lines: o.context_lines,
            pathspec: o.pathspec,
            ignore_whitespace: o.ignore_whitespace,
            force_text: o.force_text,
            reverse: o.reverse,
        }
    }
}

impl From<crate::cmd::diff::SideBySideChangeType> for p::SideBySideChangeType {
    fn from(t: crate::cmd::diff::SideBySideChangeType) -> Self {
        match t {
            crate::cmd::diff::SideBySideChangeType::Unchanged => {
                p::SideBySideChangeType::Unchanged
            }
            crate::cmd::diff::SideBySideChangeType::Added => {
                p::SideBySideChangeType::Added
            }
            crate::cmd::diff::SideBySideChangeType::Removed => {
                p::SideBySideChangeType::Removed
            }
            crate::cmd::diff::SideBySideChangeType::Modified => {
                p::SideBySideChangeType::Modified
            }
            crate::cmd::diff::SideBySideChangeType::Empty => {
                p::SideBySideChangeType::Empty
            }
        }
    }
}

impl From<crate::cmd::diff::SideBySideLine> for p::SideBySideLine {
    fn from(l: crate::cmd::diff::SideBySideLine) -> Self {
        let change_type_proto: p::SideBySideChangeType = l.change_type.into();
        p::SideBySideLine {
            left_line_no: l.left_line_no,
            right_line_no: l.right_line_no,
            left_content: l.left_content,
            right_content: l.right_content,
            change_type: change_type_proto as i32,
        }
    }
}

impl From<crate::cmd::diff::SideBySideFile> for p::SideBySideFile {
    fn from(f: crate::cmd::diff::SideBySideFile) -> Self {
        p::SideBySideFile {
            path: f.path,
            additions: f.additions as u64,
            deletions: f.deletions as u64,
            is_binary: f.is_binary,
            is_rename: f.is_rename,
            lines: f.lines.into_iter().map(Into::into).collect(),
        }
    }
}

impl From<crate::cmd::diff::SideBySideDiffResult> for p::SideBySideDiffResult {
    fn from(r: crate::cmd::diff::SideBySideDiffResult) -> Self {
        p::SideBySideDiffResult {
            files: r.files.into_iter().map(Into::into).collect(),
            total_additions: r.total_additions as u64,
            total_deletions: r.total_deletions as u64,
        }
    }
}

impl From<crate::cmd::merge::MergeAnalysisResult> for p::MergeAnalysisResult {
    fn from(r: crate::cmd::merge::MergeAnalysisResult) -> Self {
        p::MergeAnalysisResult {
            is_none: r.is_none,
            is_normal: r.is_normal,
            is_up_to_date: r.is_up_to_date,
            is_fast_forward: r.is_fast_forward,
            is_unborn: r.is_unborn,
        }
    }
}

impl From<crate::cmd::merge::MergePreferenceResult>
    for p::MergePreferenceResult
{
    fn from(r: crate::cmd::merge::MergePreferenceResult) -> Self {
        p::MergePreferenceResult {
            is_none: r.is_none,
            is_no_fast_forward: r.is_no_fast_forward,
            is_fastforward_only: r.is_fastforward_only,
        }
    }
}

impl From<crate::cmd::merge::MergeOptions> for p::MergeOptions {
    fn from(o: crate::cmd::merge::MergeOptions) -> Self {
        p::MergeOptions {
            find_renames: o.find_renames,
            fail_on_conflict: o.fail_on_conflict,
            skip_reuc: o.skip_reuc,
            no_recursive: o.no_recursive,
            rename_threshold: o.rename_threshold,
            target_limit: o.target_limit,
            recursion_limit: o.recursion_limit,
        }
    }
}

impl From<p::MergeOptions> for crate::cmd::merge::MergeOptions {
    fn from(o: p::MergeOptions) -> Self {
        crate::cmd::merge::MergeOptions {
            find_renames: o.find_renames,
            fail_on_conflict: o.fail_on_conflict,
            skip_reuc: o.skip_reuc,
            no_recursive: o.no_recursive,
            rename_threshold: o.rename_threshold,
            target_limit: o.target_limit,
            recursion_limit: o.recursion_limit,
        }
    }
}

impl From<p::MergeCommitParams> for crate::cmd::merge::MergeCommitParams {
    fn from(p: p::MergeCommitParams) -> Self {
        crate::cmd::merge::MergeCommitParams {
            their_commit: p.their_commit.unwrap_or_default().into(),
            author: p.author.unwrap_or_default().into(),
            committer: p.committer.unwrap_or_default().into(),
            message: p.message,
            update_ref: p.update_ref,
            options: p.options.map(Into::into),
        }
    }
}

impl From<crate::cmd::merge::MergeTreeResult> for p::MergeTreeResult {
    fn from(r: crate::cmd::merge::MergeTreeResult) -> Self {
        p::MergeTreeResult {
            tree_id: Some(r.tree_id.into()),
            has_conflicts: r.has_conflicts,
        }
    }
}

impl From<p::SquashCommitParams> for crate::cmd::merge::SquashCommitParams {
    fn from(p: p::SquashCommitParams) -> Self {
        crate::cmd::merge::SquashCommitParams {
            their_commit: p.their_commit.unwrap_or_default().into(),
            options: p.options.map(Into::into),
        }
    }
}

impl From<crate::cmd::tag::TagItem> for p::TagItem {
    fn from(t: crate::cmd::tag::TagItem) -> Self {
        p::TagItem {
            name: t.name,
            oid: Some(t.oid.into()),
            target: Some(t.target.into()),
            is_annotated: t.is_annotated,
            message: t.message,
            tagger: t.tagger,
            tagger_email: t.tagger_email,
        }
    }
}

impl From<crate::cmd::tag::TagSummary> for p::TagSummary {
    fn from(s: crate::cmd::tag::TagSummary) -> Self {
        p::TagSummary {
            total_count: s.total_count as u64,
        }
    }
}

impl From<p::TagInitParams> for crate::cmd::tag::TagInitParams {
    fn from(p: p::TagInitParams) -> Self {
        crate::cmd::tag::TagInitParams {
            name: p.name,
            target: p.target.unwrap_or_default().into(),
            message: p.message,
            tagger: p.tagger.map(Into::into),
            force: p.force,
        }
    }
}

impl From<p::TagDeleteParams> for crate::cmd::tag::TagDeleteParams {
    fn from(p: p::TagDeleteParams) -> Self {
        crate::cmd::tag::TagDeleteParams { name: p.name }
    }
}

impl From<p::TagRenameParams> for crate::cmd::tag::TagRenameParams {
    fn from(p: p::TagRenameParams) -> Self {
        crate::cmd::tag::TagRenameParams {
            old_name: p.old_name,
            new_name: p.new_name,
            force: p.force,
        }
    }
}

impl From<p::TagUpdateMessageParams>
    for crate::cmd::tag::TagUpdateMessageParams
{
    fn from(p: p::TagUpdateMessageParams) -> Self {
        crate::cmd::tag::TagUpdateMessageParams {
            name: p.name,
            message: p.message,
            tagger: p.tagger.unwrap_or_default().into(),
            force: p.force,
        }
    }
}

impl From<crate::cmd::tree::TreeKind> for p::TreeKind {
    fn from(k: crate::cmd::tree::TreeKind) -> Self {
        match k {
            crate::cmd::tree::TreeKind::Blob => p::TreeKind::Blob,
            crate::cmd::tree::TreeKind::Tree => p::TreeKind::Tree,
            crate::cmd::tree::TreeKind::LfsPointer => p::TreeKind::LfsPointer,
        }
    }
}

impl From<crate::cmd::tree::TreeInfo> for p::TreeInfo {
    fn from(i: crate::cmd::tree::TreeInfo) -> Self {
        p::TreeInfo {
            oid: Some(i.oid.into()),
            entry_count: i.entry_count as u64,
            is_empty: i.is_empty,
        }
    }
}

impl From<crate::cmd::tree::TreeEntry> for p::TreeEntry {
    fn from(e: crate::cmd::tree::TreeEntry) -> Self {
        let kind_proto: p::TreeKind = e.kind.into();
        p::TreeEntry {
            name: e.name,
            oid: Some(e.oid.into()),
            kind: kind_proto as i32,
            filemode: e.filemode,
            is_binary: e.is_binary,
            is_lfs: e.is_lfs,
            last_commit_message: String::new(),
            last_commit_time: String::new(),
            last_commit_author_name: String::new(),
            last_commit_author_email: String::new(),
        }
    }
}

impl From<crate::cmd::blame::CommitBlameHunk> for p::CommitBlameHunk {
    fn from(h: crate::cmd::blame::CommitBlameHunk) -> Self {
        p::CommitBlameHunk {
            commit_oid: Some(h.commit_oid.into()),
            final_start_line: h.final_start_line,
            final_lines: h.final_lines,
            orig_start_line: h.orig_start_line,
            orig_lines: h.orig_lines,
            boundary: h.boundary,
            orig_path: h.orig_path,
        }
    }
}

impl From<crate::cmd::blame::CommitBlameLine> for p::CommitBlameLine {
    fn from(l: crate::cmd::blame::CommitBlameLine) -> Self {
        p::CommitBlameLine {
            commit_oid: Some(l.commit_oid.into()),
            line_no: l.line_no,
            content: l.content,
            orig_path: l.orig_path,
        }
    }
}

impl From<p::BlameOptions> for crate::cmd::blame::BlameOptions {
    fn from(o: p::BlameOptions) -> Self {
        crate::cmd::blame::BlameOptions {
            min_line: o.min_line.map(|l| l as usize),
            max_line: o.max_line.map(|l| l as usize),
            track_copies_same_file: o.track_copies_same_file,
            track_copies_same_commit_moves: o.track_copies_same_commit_moves,
            ignore_whitespace: o.ignore_whitespace,
        }
    }
}

impl From<p::ArchiveOptions> for crate::cmd::archive::ArchiveOptions {
    fn from(o: p::ArchiveOptions) -> Self {
        crate::cmd::archive::ArchiveOptions {
            tree: o.tree.unwrap_or_default().into(),
            prefix: o.prefix,
            pathspec: o.pathspec,
        }
    }
}

impl From<p::BlobLoadParams> for crate::cmd::blob::BlobLoadParams {
    fn from(p: p::BlobLoadParams) -> Self {
        crate::cmd::blob::BlobLoadParams {
            id: p.id.unwrap_or_default().into(),
            path: p.path,
        }
    }
}

impl From<p::BlobSizeParams> for crate::cmd::blob::BlobSizeParams {
    fn from(p: p::BlobSizeParams) -> Self {
        crate::cmd::blob::BlobSizeParams {
            id: p.id.unwrap_or_default().into(),
            path: p.path,
        }
    }
}

impl From<p::BlobUploadParams> for crate::cmd::blob::BlobUploadParams {
    fn from(p: p::BlobUploadParams) -> Self {
        crate::cmd::blob::BlobUploadParams {
            blob: p.blob,
            path: p.path,
        }
    }
}

impl From<p::BlobChunkParam> for crate::cmd::blob::BlobChunkParam {
    fn from(p: p::BlobChunkParam) -> Self {
        crate::cmd::blob::BlobChunkParam {
            path: p.path,
            oid: p.oid.unwrap_or_default().into(),
            size: p.size as usize,
            offset: p.offset as usize,
        }
    }
}

impl From<crate::cmd::blob::BlobChunk> for p::BlobChunk {
    fn from(c: crate::cmd::blob::BlobChunk) -> Self {
        p::BlobChunk {
            param: Some(c.param.into()),
            chunk: c.chunk,
        }
    }
}

impl From<p::InitRepoParams> for crate::cmd::init::InitRepositoriesParams {
    fn from(p: p::InitRepoParams) -> Self {
        crate::cmd::init::InitRepositoriesParams {
            namespace: p.namespace,
            repo_name: p.repo_name,
            default_branch: p.default_branch,
            description: p.description,
            initialize_with_readme: p.initialize_with_readme,
            enable_lfs: p.enable_lfs,
        }
    }
}

impl From<crate::cmd::blob::BlobChunkParam> for p::BlobChunkParam {
    fn from(p: crate::cmd::blob::BlobChunkParam) -> Self {
        p::BlobChunkParam {
            path: p.path,
            oid: Some(p.oid.into()),
            size: p.size as u64,
            offset: p.offset as u64,
        }
    }
}