import moment, { Moment } from 'moment'

import {
  EntityIncident,
  EntityIncidentJiraIssueLink,
  IncidentUpdateIncidentReq
} from 'apiClient/services/devops/interface'

interface AntdIncidentCreateAdaptor {
  name?: string
  status?: string
  tier?: string
  components?: string[]
  biz_regions?: string[]
  oncallers?: string[]
  leaders?: string[]
  fbowners?: string[]
  jira_issues?: string[]
  description?: string
  war_room_id?: number
  need_generate_feishu: boolean
}

interface AntdIncidentEditAdaptor {
  id?: number
  name?: string
  created_at?: string
  updated_at?: string
  status?: string
  tier?: string
  components?: string[]
  biz_regions?: string[]
  oncallers?: string[]
  fbowners?: string[]
  leaders?: string[]
  feishu_url?: string
  jira_issues?: string[]
  description?: string
  war_room_id?: number
  incident_start_time?: string | Moment | null
  incident_resolve_time?: string | Moment | null
}

interface IncidentTTRRecord {
  incident_start_time?: string
  incident_resolve_time?: string
}

function incidentJiraLinksToFormValues(
  incident: Pick<EntityIncident, 'jira_issue_links' | 'jira_issues'>
): string[] | undefined {
  if (incident.jira_issue_links && incident.jira_issue_links.length > 0) {
    return incident.jira_issue_links
      .map((item) => item.url)
      .filter((item): item is string => !!item)
  }

  return incident.jira_issues?.split(' ').filter((item) => item.length > 0)
}

function formJiraLinksToRequestValues(
  jiraIssues?: string[]
): EntityIncidentJiraIssueLink[] | undefined {
  const normalized = jiraIssues?.filter(
    (item) => item && item.trim().length > 0
  )
  if (!normalized || normalized.length === 0) {
    return undefined
  }

  return normalized.map((item) => ({ url: item.trim() }))
}

function formsIncidentConvertToAntdIncident(
  incident: EntityIncident
): AntdIncidentEditAdaptor {
  const ret: AntdIncidentEditAdaptor = {
    id: incident.id,
    name: incident.name,
    created_at: incident.created_at,
    status: incident.status,
    tier: incident.tier,
    components: incident.components?.split(' '),
    biz_regions: incident.biz_regions?.split(' '),
    oncallers: incident.oncallers?.map((p) => p.email!),
    leaders: incident.leaders?.map((p) => p.email!),
    fbowners: incident.fbowners?.map((p) => p.email!),
    feishu_url: incident.feishu_url,
    jira_issues: incidentJiraLinksToFormValues(incident),
    description: incident.description,
    war_room_id: incident.war_room_id,
    incident_start_time: incident.incident_start_time,
    incident_resolve_time: incident.incident_resolve_time
  }
  return ret
}

function serializeIncidentTime(
  value?: string | Moment | null
): string | undefined {
  if (!value) {
    return undefined
  }

  const normalized = moment.isMoment(value)
    ? value.clone().utc()
    : moment.utc(value)
  if (!normalized.isValid()) {
    return undefined
  }

  return normalized.millisecond(0).toISOString()
}

function antdIncidentEditAdaptorConvertToUpdateIncidentReq(
  incident: AntdIncidentEditAdaptor
): IncidentUpdateIncidentReq {
  console.log('options:', incident)
  const ret: IncidentUpdateIncidentReq = {
    name: incident.name,
    status: incident.status,
    tier: incident.tier,
    components: incident.components?.join(' '),
    biz_regions: incident.biz_regions?.join(' '),
    oncallers: incident.oncallers,
    leaders: incident.leaders,
    fbowners: incident.fbowners,
    feishu_url: incident.feishu_url,
    jira_issue_links: formJiraLinksToRequestValues(incident.jira_issues),
    description: incident.description,
    war_room_id: incident.war_room_id,
    incident_start_time: serializeIncidentTime(incident.incident_start_time),
    incident_resolve_time: serializeIncidentTime(incident.incident_resolve_time)
  }
  return ret
}

const regionColors: { [key: string]: string } = {
  jp: 'orange',
  apac: 'magenta',
  na: 'geekblue',
  emea: 'green'
}

const tierColors: { [key: string]: string } = {
  t0: '#79155B',
  t1: '#C23373',
  t2: '#F6635C',
  t3: '#FFBA86'
}

const statusColors: { [key: string]: string } = {
  ongoing: 'orange',
  'post-mortem': 'purple',
  'under-improvement': 'blue',
  archived: 'green'
}

const statusText: { [key: string]: string } = {
  ongoing: 'Ongoing',
  'post-mortem': 'Post Mortem',
  'under-improvement': 'Under Improvement',
  archived: 'Archived'
}

const fallbackIncidentComponents = [
  'TiDB',
  'TiKV',
  'PD',
  'Cluster-Manager',
  'Import/Export',
  'Data-Service',
  'Dataflow-Service',
  'Account',
  'Billing',
  'TiCDC',
  'DM',
  'Lightning',
  'Dumpling',
  'SLA',
  'TiDB-Optimizer',
  'TiDB-SQL',
  'TiDB-Compute',
  'Tiflash',
  'TiProxy',
  'Backup/Restore',
  'BR',
  'Serverless',
  'Essential',
  'Starter',
  'DBaaS-FE',
  'GitOps',
  'Cloud-Service',
  'API-Gateway',
  'Monitoring',
  'Config-Center'
]

const todoActionStatusColor: { [key: string]: string } = {
  open: 'orange',
  ongoing: 'blue',
  in_progress: 'blue',
  done: 'green',
  noneed: 'default'
}

const calculateTTR = (startTime: string, resolveTime: string) => {
  const start = new Date(startTime)
  const resolve = new Date(resolveTime)
  const diff = Math.abs(resolve.getTime() - start.getTime())
  return Math.trunc(diff / (60 * 1000))
}

const renderTTR = (record: IncidentTTRRecord) => {
  if (!record.incident_start_time || !record.incident_resolve_time) return ''
  return calculateTTR(record.incident_start_time!, record.incident_resolve_time)
}

export type { AntdIncidentCreateAdaptor, AntdIncidentEditAdaptor }
export {
  formsIncidentConvertToAntdIncident,
  antdIncidentEditAdaptorConvertToUpdateIncidentReq,
  formJiraLinksToRequestValues,
  regionColors,
  tierColors,
  statusColors,
  statusText,
  fallbackIncidentComponents,
  todoActionStatusColor,
  calculateTTR,
  renderTTR
}