const API = require('../../../../lib/API.js')
const { BaseStdResponse } = require('../../../../BaseStdResponse.js')
const AccessControl = require('../../../../lib/AccessControl.js')
const QgProxyManager = require('../../../../lib/Lepao/QgProxyManager')
const { lookupIpv4Region, extractIpFromServer } = require('../../../../lib/Lepao/ipRegionLookup')
const { parseDetail } = require('../../../../lib/Lepao/lepaoProxyLogDisplay')

class AdminLepaoProxyStatus extends API {
    constructor() {
        super()

        this.setPath('/Admin/Lepao/Proxy/Status')
        this.setMethod('GET')
    }

    async onRequest(req, res) {
        const { uuid, session } = req.query

        if ([uuid, session].some(v => v === '' || v == null))
            return res.json({ ...BaseStdResponse.MISSING_PARAMETER })

        if (!await AccessControl.checkSession(uuid, session))
            return res.status(401).json({ ...BaseStdResponse.ACCESS_DENIED })

        const permission = await AccessControl.getPermission(uuid)
        if (!permission.includes('admin') && !permission.includes('service'))
            return res.json({ ...BaseStdResponse.PERMISSION_DENIED })

        try {
            const snap = await QgProxyManager.getStatusSnapshot()
            const redisEntry = snap.redis_current || null
            const valid = redisEntry ? QgProxyManager.cacheStillValid(redisEntry) : false

            let nodeRegion = null
            let egressRegion = null
            if (redisEntry?.server) {
                const nip = extractIpFromServer(redisEntry.server)
                nodeRegion = nip ? await lookupIpv4Region(nip) : null
            }
            if (redisEntry?.proxyIp) egressRegion = await lookupIpv4Region(redisEntry.proxyIp)

            let lastFetchEnriched = snap.last_fetch_log || null
            if (lastFetchEnriched?.detail) {
                const d = parseDetail(lastFetchEnriched.detail)
                const pip = d.proxy_ip
                lastFetchEnriched = {
                    ...lastFetchEnriched,
                    proxy_ip_region:
                        pip && String(pip).match(/^(\d{1,3}\.){3}\d{1,3}$/) ? await lookupIpv4Region(pip) : null
                }
            }

            return res.json({
                ...BaseStdResponse.OK,
                data: {
                    proxy_enabled: snap.proxy_enabled,
                    area: snap.area,
                    area_ex: snap.area_ex,
                    isp: snap.isp,
                    distinct_extract: snap.distinct_extract,
                    updated_at: snap.updated_at,
                    extract_key_configured: snap.extract_key_configured,
                    proxy_auth_configured: snap.proxy_auth_configured,
                    current_proxy: redisEntry
                        ? {
                              server: redisEntry.server,
                              deadline: redisEntry.deadline,
                              proxy_ip: redisEntry.proxyIp,
                              request_id: redisEntry.requestId,
                              fetched_at: redisEntry.fetchedAt,
                              stale: !valid,
                              node_region: nodeRegion || '未知',
                              proxy_ip_region: egressRegion || '未知'
                          }
                        : null,
                    last_fetch_log: lastFetchEnriched
                }
            })
        } catch (e) {
            this.logger?.error?.(`AdminLepaoProxyStatus: ${e.stack || e}`)
            return res.json({ ...BaseStdResponse.ERR, msg: '读取代理状态失败' })
        }
    }
}

module.exports.AdminLepaoProxyStatus = AdminLepaoProxyStatus