import { apiRequest, apiUrl } from '@/lib/api'

import type {
  AssetImpact,
  AssetVersionComparison,
  GovernedAsset,
  GovernedAssetType,
  GovernedAssetVersion,
  KnowledgeBase,
  KnowledgeDocument,
  KnowledgeItemInput,
  KnowledgeSearchResult
} from './types'

export function listKnowledgeBases() {
  return apiRequest<KnowledgeBase[]>('/knowledge/bases')
}

export function createKnowledgeBase(payload: {
  name: string
  description: string
  scope: string
  enabled?: boolean
}) {
  return apiRequest<KnowledgeBase>('/knowledge/bases', {
    method: 'POST',
    body: JSON.stringify({ ...payload, enabled: payload.enabled ?? true })
  })
}

export function listKnowledgeDocuments(knowledgeBaseId?: number, parseStatus?: string) {
  const query = new URLSearchParams()
  if (knowledgeBaseId) query.set('knowledge_base_id', String(knowledgeBaseId))
  if (parseStatus) query.set('parse_status', parseStatus)
  const suffix = query.size ? `?${query}` : ''
  return apiRequest<KnowledgeDocument[]>(`/knowledge/documents${suffix}`)
}

export function uploadKnowledgeDocument(knowledgeBaseId: number, file: File) {
  const body = new FormData()
  body.append('file', file)
  return apiRequest<KnowledgeDocument>(
    `/knowledge/documents/upload?knowledge_base_id=${knowledgeBaseId}`,
    { method: 'POST', body }
  )
}

export function retryKnowledgeDocument(publicId: string) {
  return apiRequest<KnowledgeDocument>(`/knowledge/documents/${publicId}/retry`, {
    method: 'POST'
  })
}

export function knowledgeDocumentDownloadUrl(publicId: string) {
  return apiUrl(`/knowledge/documents/${publicId}/download`)
}

export function createKnowledgeItem(payload: KnowledgeItemInput) {
  return apiRequest('/knowledge/items', {
    method: 'POST',
    body: JSON.stringify({ ...payload, status: 'draft' })
  })
}

export function searchKnowledge(query: string, knowledgeBaseId?: number) {
  return apiRequest<KnowledgeSearchResult[]>('/knowledge/search', {
    method: 'POST',
    body: JSON.stringify({
      query,
      knowledge_base_id: knowledgeBaseId,
      limit: 8
    })
  })
}

export function listGovernedAssets(assetType: GovernedAssetType, status?: string) {
  const query = new URLSearchParams({ asset_type: assetType })
  if (status && status !== 'all') query.set('status', status)
  return apiRequest<GovernedAsset[]>(`/knowledge/assets?${query}`)
}

export function updateGovernedAssetVersion(
  publicId: string,
  version: number,
  content: Record<string, unknown>,
  changeSummary: string
) {
  return apiRequest<GovernedAssetVersion>(
    `/knowledge/assets/${publicId}/versions/${version}`,
    {
      method: 'PATCH',
      body: JSON.stringify({ content, change_summary: changeSummary })
    }
  )
}

export function submitGovernedAssetVersion(publicId: string, version: number) {
  return apiRequest<GovernedAssetVersion>(
    `/knowledge/assets/${publicId}/versions/${version}/submit`,
    { method: 'POST' }
  )
}

export function reviewGovernedAssetVersion(
  publicId: string,
  version: number,
  decision: 'approve' | 'reject',
  comment: string
) {
  return apiRequest<GovernedAssetVersion>(
    `/knowledge/assets/${publicId}/versions/${version}/${decision}`,
    {
      method: 'POST',
      body: JSON.stringify({ comment })
    }
  )
}

export function rollbackGovernedAsset(publicId: string, sourceVersion: number) {
  return apiRequest<GovernedAssetVersion>(`/knowledge/assets/${publicId}/rollback`, {
    method: 'POST',
    body: JSON.stringify({
      source_version: sourceVersion,
      change_summary: `回滚自 v${sourceVersion}`
    })
  })
}

export function getGovernedAssetImpact(publicId: string) {
  return apiRequest<AssetImpact>(`/knowledge/assets/${publicId}/impact`)
}

export function compareGovernedAssetVersions(
  publicId: string,
  left: number,
  right: number
) {
  return apiRequest<AssetVersionComparison>(
    `/knowledge/assets/${publicId}/compare?left=${left}&right=${right}`
  )
}