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

// 涉华法案领域分布
/**
 * @param {Object} params
 * @param {string} params.year - 年份（2022-2026）
 * @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.billIds - 当前法案的ID
 * @param {string[]} params.domains - 领域名称列表
 * @param {string} params.patternType - 政府结构类型，如 "统一政府"/"分裂政府"/"微弱多数"
 * @param {string} params.proposalType - 提案类型，如 "两党共同提案"/"单政党提案（共和党提案）"/"单政党提案（民主党提案）"
 * @returns {Promise<Object>} 相似法案列表
 */
export function getSimiBills(params = {}) {

  // domains 如果是数组则用逗号拼接
  const domains = Array.isArray(params.domains) 
    ? params.domains.join(',') 
    : params.domains 
  return request('/api/BillProgressPrediction/simiBills', {
    method: 'GET',
    params: {
      billIds: params.billIds,
      domains: domains,
      patternType: params.patternType,
      proposalType: params.proposalType
    }
  })
}
/**
 * 格式化日期 YYYY-MM-DD -> YYYY年M月D日
 * @param {string} dateStr - 日期字符串
 * @returns {string} 格式化后的日期
 */
function formatDate(dateStr) {
  if (!dateStr) return ''
  const match = dateStr.match(/(\d{4})-(\d{2})-(\d{2})/)
  if (match) {
    return `${match[1]}年${parseInt(match[2])}月${parseInt(match[3])}日`
  }
  return dateStr
}
/**
 * 转换相似法案 API 返回的数据为组件所需格式
 * @param {Object} apiData - API 返回的原始数据
 * @returns {Object} 转换后的统计数据和法案列表
 */
export function transformSimiBillsData(apiData) {
  if (!apiData || !apiData.data) {
    return { stats: null, bills: [] }
  }

  const data = apiData.data
  const simiBills = data.simi_bills || []
  
  // 直接使用 API 返回的统计数据
  const stats = {
    totalBills: data.count || simiBills.length,
    becameLaw: data.become_law || 0,
    notPassedOrShelved: (data.count || simiBills.length) - (data.become_law || 0),
    medianDays: data.become_law_avg_days || 0,
    passRate: data.become_law_prop ? (data.become_law_prop * 100).toFixed(1) : '0'
  }

  // 转换法案列表格式
  const transformedBills = simiBills.map(bill => ({
    id: bill.bill_id,
    title: bill.bill_name || bill.bill_id,
    proposalDate: bill.proposed_date ? formatDate(bill.proposed_date) : '',
    areas: bill.bill_domain ? (Array.isArray(bill.bill_domain) ? bill.bill_domain : [bill.bill_domain]) : [],
    proposer: bill.key_sponsor_name || extractProposer(bill.bill_sponsors),
    proposerParty: bill.key_sponsor_party || '',
    coProposers: bill.co_sponsor_desc || bill.bill_proposal_desc || '',
    proposalType: bill.bill_proposal_type || '',
    governmentType: formatGovernmentType(bill.poli_pattern_type, bill.poli_pattern_desc),
    patternType: bill.poli_pattern_type || '',
    billStatus: bill.bill_status || '',
    passDays: bill.bill_action_days || calculateTotalDays(bill.bill_actions),
    yearsDifference: bill.years_difference || 0,
    billActions: bill.bill_actions || [],
    billSponsors: bill.bill_sponsors || [],
    selected: true // 默认全选
  }))

  return { stats, bills: transformedBills }
}
 
/**
 * 从提案人列表中提取主提案人
 * @param {Array} sponsors - 提案人列表
 * @returns {string} 主提案人姓名
 */
function extractProposer(sponsors) {
  if (!sponsors || sponsors.length === 0) return ''
  const mainProposer = sponsors.find(s => s.sponsor_type === '提案人')
  return mainProposer ? mainProposer.person_name : ''
}
/**
 

/**
 * 计算法案总耗时
 * @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 {
    // 提案标题
    title: data.bill_name_zh  ,
    // 提案时间 - 从政治格局描述中提取
    date: extractDateFromDesc(data.poli_pattern_desc)  ,
    // 涉及领域 TAG - 使用 domain_name
    areas: Array.isArray(data.domain_name) ? data.domain_name : (data.domain_name ? [data.domain_name] : []),
    // 政策领域完整选项列表 - 使用 bill_domain（用于筛选下拉框）
    billDomain: Array.isArray(data.bill_domain) ? data.bill_domain : [],
    // 政策领域默认已选项 - 使用 domain_name
    defaultDomains: Array.isArray(data.domain_name) ? data.domain_name : (data.domain_name ? [data.domain_name] : []),
    // 提案人
    proposer: mainProposer ? mainProposer.person_name : '',
    // 共同提案人
    coProposers: coProposersDesc,
    // 政府结构类型
    governmentType: formatGovernmentType(data.poli_pattern_type, data.poli_pattern_desc),
    // 政治格局类型（用于筛选条件默认值）
    patternType: data.poli_pattern_type || '统一政府',
    // 原始数据，供筛选条件使用
    _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'], 
    // 法案预算规模
    budgetScale: ['trillion_plus'],
    // 对方党派提案人
    oppositionProposer: ['none'],
    // 提案时间
    proposalTime: ['recent_5']
  }
}
/**
 * 获取预测分析结果
 * @param {Object} params - 请求参数
 * @param {string} params.bill_id - 当前法案ID
 * @param {string} params.bill_name - 当前法案名称
 * @param {Array} params.bill_actions - 当前法案动作列表
 * @param {Array} params.bill_sponsors - 当前法案提案人列表
 * @param {Array} params.simi_bills - 用户勾选的相似法案列表
 * @returns {Promise<Object>} 预测分析结果
 */
export function getPassProd(params) {
  return request('/api/BillProgressPrediction/passProd', {
    method: 'POST',
    data: params
  })
}