import request from "@/api/request.js";

// 涉华法案领域分布
/**
 * @param {Object} params
 * @param {string} params.year - 年份
 * @param {string} [params.status] - 状态：提出法案/通过法案
 */
export function getBillIndustry(params) {
    return request({
        method: 'GET',
        url: `/api/BillOverview/billIndustry/${params.year}`,
        params: { status: params.status }
    })
}

// 涉华法案统计
/**
 * @param {Object} params
 * @param {string} [params.dateDesc] - 时间范围：近一年/近两年/近三年/全部
 * @param {string} [params.industryId] - 行业领域 ID
 */
export function getBillCount(params) {
    return request({
        method: 'GET',
        url: `/api/BillOverview/billCount`,
        params
    })
}

// 近期美国国会各委员会涉华提案数量汇总
/**
 * @param {Object} params
 * @param {string} params.dateDesc - 时间范围：近一周/近一月/近一年
 */
export function getStatisticsBillCountByCommittee(params) {
    return request({
        method: 'GET',
        url: `/api/BillOverview/statisticsBillCountByCommittee`,
        params
    })
}

// 获取关键条款
export function getBillOverviewKeyTK() {
    return request({
        method: 'GET',
        url: `/api/BillOverview/keyTk`,

    })
}

// 获取热门法案列表
export function getHotBills() {
    return request({
        method: 'GET',
        url: '/api/BillOverview/hotBills',
    })
}

// 获取法案风险信号
/**
 * @param {moduleId} 
 */
export function getBillRiskSignal(params) {
    return request({
        method: 'GET',
        // 这个是之前的接口地址，现在接口地址换成新的了所以使用新地址
        // url: '/api/BillOverview/riskSignal',
        url: `/api/commonFeature/riskSignal/${params.moduleId}`,
    })
}

// 获取新闻资讯
/**
 * @param {moduleId} 
 */
export function getNews(params) {
    return request({
        method: 'GET',
        url: `/api/commonFeature/news/${params.moduleId}`,
    })
}

// 获取社交媒体
/**
 * @param {moduleId} 
 */
export function getRemarks(params) {
    return request({
        method: 'GET',
        url: `/api/commonFeature/remarks/${params.moduleId}`,
    })
}

// 根据法案类型获取法案列表
/**
 * @param {type} 
 */
export function getBillsByType(params) {
    return request({
        method: 'GET',
        url: '/api/BillOverview/bills',
        params,
    })
}

// 根据行业领域字典列表
export function getHylyList() {
    return request({
        method: 'GET',
        url: `/api/billImpactAnalysis/industry/hylyList`,
    })
}

// 获取法案提出部门
/**
 * @param {year} 
 */
export function getBillPostOrg(params) {
    return request({
        method: 'GET',
        url: `/api/BillOverview/billPostOrg/${params.year}`,
    })
}

// 获取涉华法案进展分布
/**
 * @param {year}
 */
export function getBillProcess(params) {
    return request({
        method: 'GET',
        url: `/api/BillOverview/billsProcess/${params.year}`,
    })
}

    // 获取资源库法案
export function getBills(params, signal) {
    return request({
        method: 'GET',
        url: `/api/BillOverview/bills`,
        params,
        signal
    })
}

// 获取资源库国会议员
export function getBillsPerson(params, signal) {
    return request({
        method: 'GET',
        url: `/api/BillOverview/billsPerson`,
        params,
        signal
    })
}

// 获取议员合作关系
export function getBillsPersonRel(params, signal) {
    return request({
        method: 'GET',
        url: `/api/BillOverview/billsPersonRel`,
        params,
        signal
    })
}

// 获取涉华委员会及其法案
export function getBillsIsCnCommittee(params, signal) {
    return request({
        method: 'GET',
        url: `/api/BillOverview/billsIsCnCommittee`,
        params,
        signal
    })
}

// 获取提出部门列表
export function getPostOrgList() {
    return request({
        method: 'GET',
        url: `/api/BillDict/department`,
    })
}

// 获取提出议员列表
export function getPostMemberList() {
    return request({
        method: 'GET',
        url: `/api/BillDict/member`,
    })
}


/**
 * 获取筛选项配置 - 行业列表
 * GET /api/billImpactAnalysis/industry/hylyList
 */
export async function getIndustryKeyList() {
    return request('/api/billImpactAnalysis/industry/hylyList', {
        method: 'GET',
    })
}

/**
 * 获取进度阶段配置
 * GET /api/commonDict/bill/stage
 */
export async function getBillStageConfig() {
    return request('/api/commonDict/bill/stage', {
        method: 'GET',
    })
}

/**
 * 获取法案列表
 * GET /api/personHomepage/historyBill/{personId}
 * @param {string} personId - 人物ID
 * @param {Object} params - 查询参数（不包含分页参数）
 */
export async function getHistoryBillList(personId, params = {}) {
    const queryString = Object.entries(params)
        .filter(([, value]) => value !== undefined && value !== null && value !== '')
        .map(([key, value]) => {
            if (Array.isArray(value)) {
                return value.map(v => `${encodeURIComponent(key)}=${encodeURIComponent(v)}`).join('&')
            }
            return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
        })
        .join('&')

    const url = queryString
        ? `/api/personHomepage/historyBill/${personId}?${queryString}`
        : `/api/personHomepage/historyBill/${personId}`

    return request(url, {
        method: 'GET',
    })
}

/**
 * 获取法案列表（含阶段字典）
 * @param {string} personId - 人物ID
 * @param {Object} params - 查询参数
 */
export async function getHistoryBillListWithStage(personId, params = {}) {
    const stageRes = await getBillStageConfig()
    const billRes = await getHistoryBillList(personId, params)

    return {
        stageConfig: stageRes,
        billList: billRes,
    }
}

// /**
//  * 获取潜在提案举措分析
//  * GET /api/personHomepage/historyBill/clause/{personId}
//  * @param {string} personId - 人物ID
//  * @param {Object} params - 查询参数
//  */
// export async function getPotentialClauseAnalysis(personId, params = {}) {
//     const queryString = Object.entries(params)
//         .filter(([, value]) => value !== undefined && value !== null && value !== '')
//         .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
//         .join('&')

//     const url = queryString
//         ? `/api/personHomepage/historyBill/clause/${personId}?${queryString}`
//         : `/api/personHomepage/historyBill/clause/${personId}`

//     return request(url, {
//         method: 'GET',
//     })
// }

/**
 * 获取排序选项
 */
 
export function getSortOptions() {
    return Promise.resolve({
        code: 200,
        data: [
            { value: 'latestMotionTimeDesc', label: '最新修议时间倒序' },
            { value: 'latestMotionTimeAsc', label: '最新修议时间正序' },
        ],
    })
}

export async function getPotentialNewsList(personId, params = {}) {
    const queryString = Object.entries(params)
        .filter(([, value]) => value !== undefined && value !== null && value !== '')
        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
        .join('&')

    const url = queryString
        ? `/api/personHomepage/historyBill/clause/${personId}?${queryString}`
        : `/api/personHomepage/historyBill/clause/${personId}`

    return request(url, {
        method: 'GET',
    })
}

export async function getPotentialNewsKeywords(personId) {
    return request(`/api/personHomepage/historyBill/clauseKeyword/${personId}`, {
        method: 'GET',
    })
}
 




/**
 * 获取法案进展预测基础数据
 * @param {string} billId - 法案ID，如 "119_HR_1"
 * @returns {Promise<Object>} 预测基础数据
 */
export function getProgressPrediction(billId) {
  return request('/api/BillProgressPrediction/progressPrediction', {
    method: 'GET',
    params: { billId }
  })
}

/**
 * 获取相似法案列表
 * @param {Object} params - 查询参数
 * @param {string} params.patternType - 政府结构类型，如 "统一政府"
 * @param {string} params.proposalType - 提案类型，默认 "两党共同提案"
 * @returns {Promise<Object>} 相似法案列表
 */
export function getSimiBills(params = {}) {
  return request('/api/BillProgressPrediction/simiBills', {
    method: 'GET',
    params: {
      patternType: params.patternType || '统一政府',
      proposalType: params.proposalType || '两党共同提案',
      ...params
    }
  })
}

/**
 * 转换相似法案 API 返回的数据为组件所需格式
 * @param {Object} apiData - API 返回的原始数据
 * @returns {Object} 转换后的统计数据和法案列表
 */
export function transformSimiBillsData(apiData) {
  if (!apiData || !apiData.data || !Array.isArray(apiData.data)) {
    return { stats: null, bills: [] }
  }

  const bills = apiData.data
  
  // 计算统计数据
  let becameLaw = 0
  let notPassedOrShelved = 0
  let totalDays = 0
  let completedBills = 0

  bills.forEach(bill => {
    const actions = bill.bill_actions || []
    const hasBecameLaw = actions.some(a => 
      a.action_type === 'BecameLaw' || 
      a.action_type === 'President' && a.action_desc?.includes('签署')
    )
    
    if (hasBecameLaw) {
      becameLaw++
      // 计算耗时
      if (actions.length >= 2) {
        const firstDate = new Date(actions[0].action_date)
        const lastDate = new Date(actions[actions.length - 1].action_date)
        const days = Math.ceil((lastDate - firstDate) / (1000 * 60 * 60 * 24))
        if (days > 0) {
          totalDays += days
          completedBills++
        }
      }
    } else {
      notPassedOrShelved++
    }
  })

  const medianDays = completedBills > 0 ? Math.round(totalDays / completedBills) : 223
  const passRate = bills.length > 0 ? ((becameLaw / bills.length) * 100).toFixed(1) : '0'

  const stats = {
    totalBills: bills.length,
    becameLaw,
    notPassedOrShelved,
    medianDays,
    passRate
  }

  // 转换法案列表格式
  const transformedBills = bills.map(bill => ({
    id: bill.bill_id,
    title: bill.bill_name || bill.bill_id,
    tags: [bill.poli_pattern_type, bill.bill_proposal_type].filter(Boolean),
    passTime: extractPassTime(bill.bill_actions),
    totalDays: calculateTotalDays(bill.bill_actions),
    selected: true, // 默认全选
    _raw: bill
  }))

  return { stats, bills: transformedBills }
}

/**
 * 从法案动作中提取通过时间
 * @param {Array} actions - 法案动作列表
 * @returns {string} 通过时间
 */
function extractPassTime(actions) {
  if (!actions || actions.length === 0) return ''
  // 找到最后一个动作的日期
  const lastAction = actions[actions.length - 1]
  if (lastAction && lastAction.action_date) {
    const date = new Date(lastAction.action_date)
    return `${date.getFullYear()}年${date.getMonth() + 1}月${date.getDate()}日`
  }
  return ''
}

/**
 * 计算法案总耗时
 * @param {Array} actions - 法案动作列表
 * @returns {number} 总天数
 */
function calculateTotalDays(actions) {
  if (!actions || actions.length < 2) return 0
  const firstDate = new Date(actions[0].action_date)
  const lastDate = new Date(actions[actions.length - 1].action_date)
  return Math.ceil((lastDate - firstDate) / (1000 * 60 * 60 * 24))
}

/**
 * 解析 billId 从路由参数
 * 路由格式: ProgressForecast/:id
 * billId 格式: 119_HR_1 (国会届次_法案类型_法案编号)
 * @param {string} id - 路由中的 id 参数
 * @returns {string} 完整的 billId
 */
export function parseBillId(id) {
  // 如果 id 已经包含完整格式，直接返回
  if (id && id.includes('_')) {
    return id
  }
  // 否则根据业务规则构建 billId
  // 这里假设默认是 119 届国会的 HR 类型法案
  return `119_HR_${id}`
}

/**
 * 转换 API 返回的数据为组件所需格式
 * @param {Object} apiData - API 返回的原始数据
 * @returns {Object} 转换后的提案信息
 */
export function transformProposalInfo(apiData) {
  if (!apiData || !apiData.data) {
    return null
  }
  
  const data = apiData.data
  
  // 解析提案人信息
  const sponsors = data.bill_sponsors || []
  const mainProposer = sponsors.find(s => s.sponsor_type === '提案人')
  const coProposers = sponsors.filter(s => s.sponsor_type !== '提案人')
  
  // 构建共同提案人描述
  let coProposersDesc = ''
  if (coProposers.length > 0) {
    const partyGroups = {}
    coProposers.forEach(s => {
      const party = s.party_name || '未知'
      partyGroups[party] = (partyGroups[party] || 0) + 1
    })
    coProposersDesc = Object.entries(partyGroups)
      .map(([party, count]) => `${party}${count}人`)
      .join('；')
  } else {
    coProposersDesc = data.proposal_desc || '无'
  }
  
  return {
    // 提案标题 - 需要从其他 API 获取或使用默认值
    title: data.bill_title || 'H.R.1-大而美法案',
    // 提案时间 - 从政治格局描述中提取或使用默认值
    date: extractDateFromDesc(data.poli_pattern_desc) || '2025年5月20日',
    // 涉及领域
    areas: data.domain_name || [],
    // 选举周期阶段 - 从政治格局描述推断
    electionPhase: inferElectionPhase(data.poli_pattern_desc) || '执政初期/蜜月期',
    // 提案人
    proposer: mainProposer ? `${mainProposer.person_name}` : '',
    // 共同提案人
    coProposers: coProposersDesc,
    // 提案人职务 - 需要从其他 API 获取
    proposerPosition: data.proposer_position || '委员会主席',
    // 政府结构类型
    governmentType: formatGovernmentType(data.poli_pattern_type, data.poli_pattern_desc),
    // 法案预算规模 - 需要从其他 API 获取
    budgetScale: data.budget_scale || '4万亿美元',
    // 原始数据，供筛选条件使用
    _raw: data
  }
}

/**
 * 从政治格局描述中提取日期
 * @param {string} desc - 政治格局描述
 * @returns {string|null} 提取的日期
 */
function extractDateFromDesc(desc) {
  if (!desc) return null
  // 尝试匹配 YYYY-MM-DD 或 YYYY年M月D日 格式
  const match = desc.match(/(\d{4})-(\d{2})-(\d{2})/)
  if (match) {
    return `${match[1]}年${parseInt(match[2])}月${parseInt(match[3])}日`
  }
  return null
}

/**
 * 从政治格局描述推断选举周期阶段
 * @param {string} desc - 政治格局描述
 * @returns {string} 选举周期阶段
 */
function inferElectionPhase(desc) {
  if (!desc) return '执政初期/蜜月期'
  // 根据描述中的关键词推断
  if (desc.includes('就职')) {
    return '执政初期/蜜月期'
  }
  return '执政初期/蜜月期'
}

/**
 * 格式化政府结构类型
 * @param {string} type - 政府类型
 * @param {string} desc - 详细描述
 * @returns {string} 格式化后的政府结构类型
 */
function formatGovernmentType(type, desc) {
  if (type === '统一政府') {
    return '一致政府（总统与两院同党）'
  }
  if (type === '分立政府') {
    return '分立政府'
  }
  return type || '一致政府（总统与两院同党）'
}

/**
 * 根据提案信息生成默认筛选条件
 * @param {Object} proposalInfo - 转换后的提案信息
 * @returns {Object} 默认筛选条件
 */
export function generateDefaultFilters(proposalInfo) {
  if (!proposalInfo) return {}
  
  return {
    // 政策领域 - 使用提案的涉及领域
    policyArea: proposalInfo.areas.map(area => {
      const areaMap = {
        '能源': 'energy',
        '集成电路': 'ic',
        '人工智能': 'ai',
        '生物技术': 'biotech'
      }
      return areaMap[area] || area.toLowerCase()
    }),
    // 提案人职务
    proposerPosition: proposalInfo.proposerPosition === '委员会主席' ? ['chairman'] : [],
    // 政府结构类型
    governmentType: proposalInfo.governmentType.includes('一致') ? ['unified'] : ['divided'],
    // 选举周期阶段
    electionPhase: proposalInfo.electionPhase.includes('蜜月') ? ['honeymoon'] : [],
    // 法案预算规模
    budgetScale: ['trillion_plus'],
    // 对方党派提案人
    oppositionProposer: ['none'],
    // 提案时间
    proposalTime: ['recent_5']
  }
}
