/**
 * 每一路入站的专属策略组。
 *
 * 一路入站配三个组，入站的 `proxy:` 指向其中的 SELECT，换线是换那个组的当前选中，
 * 不改配置文件（决策记录 0007）：
 *   SELECT     手动选。它的成员是 DIRECT、下面两个组，加上订阅里的线路
 *   AUTO       url-test，自动挑延迟最低的
 *   FALLBACK   fallback，按顺序挑第一个测得通的
 * 界面上这三个是并排的 tab。做成三个而不是让用户自己配，是因为它们就是所有 clash 配置
 * 里那三种固定的挑法，让人从零拼一遍没有意义。
 *
 * 开了链式代理时再多一个入口组，以及若干份订阅声明的副本——`dialer-proxy` 写不到策略组
 * 上，只能挂在整个订阅上（内核源码 adapter/outboundgroup/parser.go:68-70）。
 *
 * 配置里的东西属于谁全靠三条线索还原，不靠解析名字：
 *   四个组      名字由入站名推出来
 *   订阅副本    override.dialer-proxy 指向哪一路的入口组
 *   副本的来源  url 和哪个用户订阅相同
 */
import type { ConfigObject } from '../vendor/config-editor/index.ts'
import { resolveDestination } from './inbounds.ts'
import type { Inbound } from './inbounds.ts'
import { lastSwitchableGroup, resolveChain } from './outbound-chain.ts'
import type { RuntimeNode } from './outbound-chain.ts'

/**
 * Patchbay 自动创建的策略组和订阅的名字前缀。
 *
 * 名字是识别它们的唯一可靠标记。注释靠不住——配置改写引擎重建整个被碰到的顶层段落，
 * 段落内的注释会丢（决策记录 0002）。改这个前缀会让已有配置里的组失去标记，别改。
 */
export const GENERATED_PREFIX = 'patchbay:'

export function isGenerated(name: string): boolean {
  return name.startsWith(GENERATED_PREFIX)
}

/** 手动选的那个组。入站的 `proxy:` 指向它，它的当前选中决定这一路走哪。 */
export function proxyGroupName(inbound: string): string {
  return `${GENERATED_PREFIX}${inbound}`
}

/** 自动测速组，作为 SELECT 的一个成员出现。 */
export function autoGroupName(inbound: string): string {
  return `${GENERATED_PREFIX}${inbound} AUTO`
}

/** 故障转移组，同上。 */
export function fallbackGroupName(inbound: string): string {
  return `${GENERATED_PREFIX}${inbound} FALLBACK`
}

/** 链式代理的入口组。订阅副本的 `dialer-proxy` 指向它。 */
export function chainGroupName(inbound: string): string {
  return `${GENERATED_PREFIX}${inbound} 链式`
}

/**
 * 一个出站在界面上叫什么。
 *
 * 生成的组要去掉 `patchbay:` 前缀和入站名。用户从没建过这些组，让他在卡片和链条上读到
 * `patchbay:test1 FALLBACK` 只是噪音——那一屏本来就是这一路入站的详情，名字里再重复
 * 一遍入站名不增加任何信息。
 */
export function displayName(name: string): string {
  if (!isGenerated(name)) return name
  const rest = name.slice(GENERATED_PREFIX.length)
  for (const [suffix, label] of [
    [' AUTO', 'AUTO'],
    [' FALLBACK', 'FALLBACK'],
    [' 链式', '链式代理'],
  ] as const) {
    if (rest.endsWith(suffix)) return label
  }
  return rest
}

/** 这一路的三个组，按界面上的显示顺序。 */
function ownGroups(inbound: string): Array<{ name: string; label: string }> {
  return [
    { name: proxyGroupName(inbound), label: 'SELECT' },
    { name: autoGroupName(inbound), label: 'AUTO' },
    { name: fallbackGroupName(inbound), label: 'FALLBACK' },
  ]
}

/** FNV-1a。只用来给名字和文件名去重，不是安全用途，所以不引哈希库，浏览器端也要能算。 */
function shortHash(text: string): string {
  let h = 0x811c9dc5
  for (let i = 0; i < text.length; i += 1) {
    h ^= text.charCodeAt(i)
    h = Math.imul(h, 0x01000193) >>> 0
  }
  return h.toString(16).padStart(8, '0')
}

const pairKey = (inbound: string, source: string) => `${inbound} ${source}`

/**
 * 「某一路入站 × 某个来源订阅」这个组合对应的订阅副本叫什么。
 *
 * 名字里带哈希是因为 `proxy-providers` 是个映射，两个组合撞名会让其中一个被静默丢掉，
 * 表现是链式代理挂到了别的入站上。带上入站名只是为了翻配置文件时读得懂。
 */
export function chainProviderName(inbound: string, source: string): string {
  return `${GENERATED_PREFIX}chain ${inbound} ${shortHash(pairKey(inbound, source))}`
}

/**
 * 一个订阅的缓存文件落在哪。
 *
 * 内核把拉回来的内容写在这里（内核源码 component/resource/vehicle.go:42-47）。没写
 * `path:` 时它按 url 哈希自己生成一个（adapter/provider/parser.go:87），那个路径 Patchbay
 * 算不出来，所以缺的时候补一个确定的进去。
 */
export function providerCachePath(name: string): string {
  const safe = name.replace(/[^\p{L}\p{N}_-]+/gu, '-').replace(/^-+|-+$/g, '')
  return `./providers/${safe || shortHash(name)}.yaml`
}

/** 一组线路从哪来、要哪些。三个组共用同一份，它们只是挑法不同。 */
export interface GroupSpec {
  /** 成员来自哪几个订阅，写进组的 `use:` */
  sources: string[]
  /** 只要名字匹配这个正则的线路。null 表示全要 */
  filter: string | null
}

/** 一路入站的出站设置。 */
export interface OutboundSetup {
  proxy: GroupSpec
  /** 链式代理的入口。null 表示没开 */
  chain: GroupSpec | null
}

function isPlainObject(value: unknown): value is ConfigObject {
  return typeof value === 'object' && value !== null && !Array.isArray(value)
}

function groupsOf(data: ConfigObject): ConfigObject[] {
  return (Array.isArray(data['proxy-groups']) ? data['proxy-groups'] : []).filter(isPlainObject)
}

function providersOf(data: ConfigObject): ConfigObject {
  return isPlainObject(data['proxy-providers']) ? data['proxy-providers'] : {}
}

function findGroup(data: ConfigObject, name: string): ConfigObject | null {
  return groupsOf(data).find((g) => g.name === name) ?? null
}

function stringList(value: unknown): string[] {
  return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : []
}

function specOf(group: ConfigObject): GroupSpec {
  return {
    sources: stringList(group.use),
    filter: typeof group.filter === 'string' && group.filter ? group.filter : null,
  }
}

/** 用户自己配的订阅，不含 Patchbay 生成的副本。界面上「来源」能选的就是这些。 */
export function userProviders(data: ConfigObject): string[] {
  return Object.keys(providersOf(data)).filter((name) => !isGenerated(name))
}

/** 某个策略组从哪几个订阅取成员。组不存在时返回 null。 */
export function groupUses(data: ConfigObject, name: string): string[] | null {
  const group = findGroup(data, name)
  return group ? stringList(group.use) : null
}

/** 这个订阅副本是哪一路入站的。不是副本、或者认不出归属时返回 null。 */
function chainOwnerOf(provider: unknown): string | null {
  if (!isPlainObject(provider)) return null
  const override = provider.override
  if (!isPlainObject(override)) return null
  const target = override['dialer-proxy']
  if (typeof target !== 'string' || !isGenerated(target)) return null
  const suffix = ' 链式'
  if (!target.endsWith(suffix)) return null
  return target.slice(GENERATED_PREFIX.length, target.length - suffix.length)
}

/** 副本的来源订阅叫什么。靠读同一个缓存文件来认，因为名字不可靠解析。 */
function sourceOfCopy(data: ConfigObject, copy: ConfigObject): string | null {
  if (typeof copy.path !== 'string') return null
  for (const [name, entry] of Object.entries(providersOf(data))) {
    if (isGenerated(name) || !isPlainObject(entry)) continue
    if (entry.path === copy.path) return name
  }
  return null
}

/**
 * 读出这一路入站当前的出站设置。
 *
 * 返回 null 表示它还没在专属组模式下，可能是走规则表、直连，或者指向用户自己建的组。
 */
export function readSetup(data: ConfigObject, inbound: string): OutboundSetup | null {
  const proxyGroup = findGroup(data, proxyGroupName(inbound))
  if (!proxyGroup) return null

  const spec = specOf(proxyGroup)
  const providers = providersOf(data)
  const copies = spec.sources.filter((name) => chainOwnerOf(providers[name]) === inbound)

  if (copies.length === 0) return { proxy: spec, chain: null }

  const chainGroup = findGroup(data, chainGroupName(inbound))
  const sources = copies
    .map((name) => sourceOfCopy(data, providers[name] as ConfigObject))
    .filter((name): name is string => name !== null)

  return {
    proxy: { sources, filter: spec.filter },
    chain: chainGroup ? specOf(chainGroup) : { sources: [], filter: null },
  }
}

function makeGroup(
  name: string,
  type: string,
  use: string[],
  filter: string | null,
  members: string[] = [],
): ConfigObject {
  const group: ConfigObject = { name, type }
  if (members.length > 0) group.proxies = members
  if (use.length > 0) group.use = use
  if (filter) group.filter = filter
  // url-test 和 fallback 要有测速地址才知道谁快谁通。不写的话内核会借用来源订阅自己的
  // 健康检查地址（adapter/outboundgroup/parser.go:139-148），但那依赖订阅写了它，
  // 不能指望；写死一个和内核默认一致的更稳。
  if (type !== 'select') {
    group.url = 'https://www.gstatic.com/generate_204'
    group.interval = 300
  }
  return group
}

function upsert(list: ConfigObject[], entry: ConfigObject): ConfigObject[] {
  const at = list.findIndex((item) => item.name === entry.name)
  if (at < 0) return [...list, entry]
  const next = [...list]
  next[at] = entry
  return next
}

/**
 * 照着一个用户订阅做出带 `dialer-proxy` 的那一份。
 *
 * 副本是 `type: file`，读的正是原订阅那个缓存文件，自己不联网。这一点是硬性的：副本要是
 * 自己去拉，订阅地址一不可达它就是空的，而这一路入站的线路全部来自它，结果是端口还在
 * 监听却一条线都没有。派生自原订阅已经落盘的内容，原订阅有什么副本就有什么。
 *
 * 内核对 file 类型的 provider 自带文件监视（component/resource/fetcher.go:212-228），
 * 原订阅刷新写盘之后副本自动跟着更新，不需要 Patchbay 做任何事。
 *
 * `filter` 这些影响「这个订阅里有哪些线路」的字段照抄，`url` 和 `interval` 去掉，
 * 它们只对 http 类型有意义。
 */
function makeChainProvider(source: ConfigObject, inbound: string, cachePath: string): ConfigObject {
  const override = isPlainObject(source.override) ? { ...source.override } : {}
  override['dialer-proxy'] = chainGroupName(inbound)
  const { url: _url, interval: _interval, ...rest } = source
  return { ...rest, type: 'file', path: cachePath, override }
}

/**
 * 把一路入站的出站设置写回配置。
 *
 * 开了链式代理时，三个组的成员都改从订阅副本里取，因为只有副本挂着 `dialer-proxy`。
 * 用户选的来源订阅仍然可以从副本的 `url` 还原出来，所以配置文件之外不需要另存状态。
 */
export function applySetup(data: ConfigObject, inbound: string, setup: OutboundSetup): ConfigObject {
  const next = { ...data }
  const chained = setup.chain !== null
  const providers = { ...providersOf(next) }

  // 先清掉这一路原有的副本，再按新的来源重建。改来源时旧的副本必须消失，
  // 否则代理组不再引用它，它就成了一份没人用却还在定时拉取的订阅。
  for (const [name, entry] of Object.entries(providers)) {
    if (chainOwnerOf(entry) === inbound) delete providers[name]
  }

  const use: string[] = []
  if (chained) {
    for (const sourceName of setup.proxy.sources) {
      const source = providers[sourceName]
      if (!isPlainObject(source)) continue
      // 副本靠「读同一个缓存文件」认亲。原订阅没写 path 时内核按 url 哈希自己生成一个，
      // 那个路径这边算不出来，所以先给原订阅补一个确定的。
      const cachePath =
        typeof source.path === 'string' && source.path ? source.path : providerCachePath(sourceName)
      providers[sourceName] = { ...source, path: cachePath }
      const copyName = chainProviderName(inbound, sourceName)
      providers[copyName] = makeChainProvider(providers[sourceName], inbound, cachePath)
      use.push(copyName)
    }
  } else {
    use.push(...setup.proxy.sources)
  }

  const { filter } = setup.proxy
  let groups = groupsOf(next)
  groups = upsert(
    groups,
    makeGroup(proxyGroupName(inbound), 'select', use, filter, [
      'DIRECT',
      autoGroupName(inbound),
      fallbackGroupName(inbound),
    ]),
  )
  groups = upsert(groups, makeGroup(autoGroupName(inbound), 'url-test', use, filter))
  groups = upsert(groups, makeGroup(fallbackGroupName(inbound), 'fallback', use, filter))

  if (chained) {
    groups = upsert(
      groups,
      makeGroup(chainGroupName(inbound), 'select', setup.chain!.sources, setup.chain!.filter),
    )
  } else {
    groups = groups.filter((g) => g.name !== chainGroupName(inbound))
  }
  next['proxy-groups'] = groups

  if (Object.keys(providers).length === 0) delete next['proxy-providers']
  else next['proxy-providers'] = providers

  const listeners = (Array.isArray(next.listeners) ? next.listeners : []).map((entry) =>
    isPlainObject(entry) && entry.name === inbound
      ? { ...entry, proxy: proxyGroupName(inbound) }
      : entry,
  )
  if (listeners.length > 0) next.listeners = listeners

  return next
}

/** 配置里指向某个名字的地方有几处。用来判断生成的东西还有没有人在用。 */
function referencesTo(data: ConfigObject, name: string): number {
  let count = 0

  for (const entry of Array.isArray(data.listeners) ? data.listeners : []) {
    if (isPlainObject(entry) && entry.proxy === name) count += 1
  }

  for (const group of groupsOf(data)) {
    if (stringList(group.proxies).includes(name)) count += 1
    if (stringList(group.use).includes(name)) count += 1
  }

  for (const entry of Object.values(providersOf(data))) {
    if (!isPlainObject(entry) || !isPlainObject(entry.override)) continue
    if (entry.override['dialer-proxy'] === name) count += 1
  }

  for (const rule of Array.isArray(data.rules) ? data.rules : []) {
    // 规则是逗号分隔的，目标出站是其中一段，形如 MATCH,目标 或 DOMAIN,x,目标
    if (typeof rule === 'string' && rule.split(',').some((part) => part.trim() === name)) count += 1
  }

  return count
}

/**
 * 删掉没人再引用的生成组和订阅副本。
 *
 * 每次改完配置都跑一遍。删一路入站之后，它的几个组和几份副本会先后变成孤儿，不清理的话
 * 文件里就攒下一堆用户从没主动建过的东西，而副本还在按 interval 定时联网。
 *
 * 要反复扫：AUTO 和 FALLBACK 被 SELECT 引用，入口组被副本引用，副本被那三个组引用，
 * 所以删掉 SELECT 之后下一轮才轮到它们。只动带前缀的，用户自己建的一律不碰。
 */
export function pruneGenerated(data: ConfigObject): ConfigObject {
  const groups = Array.isArray(data['proxy-groups']) ? data['proxy-groups'] : []
  const keptGroups = groups.filter((group) => {
    if (!isPlainObject(group)) return true
    const name = group.name
    if (typeof name !== 'string' || !isGenerated(name)) return true
    return referencesTo(data, name) > 0
  })

  const providers = providersOf(data)
  const keptProviders = Object.entries(providers).filter(
    ([name]) => !isGenerated(name) || referencesTo(data, name) > 0,
  )
  const providersChanged = keptProviders.length !== Object.keys(providers).length

  if (keptGroups.length === groups.length && !providersChanged) return data

  const next = { ...data }
  if (keptGroups.length === 0) delete next['proxy-groups']
  else next['proxy-groups'] = keptGroups

  if (providersChanged) {
    if (keptProviders.length === 0) delete next['proxy-providers']
    else next['proxy-providers'] = Object.fromEntries(keptProviders)
  }

  return pruneGenerated(next)
}

/**
 * 把所有已接管入站的生成组按当前的生成规则重建一遍。
 *
 * 每次写配置前跑。生成的东西必须永远和生成它的代码一致，否则改过生成规则之后，早先建的
 * 那些就停在旧形状上，界面按新形状去找，找不到就静默少一块——tab 少了两个正是这么来的。
 * `applySetup` 幂等，形状没变时返回的内容一样，落盘链路会看出内容没变而跳过重载。
 */
export function syncGenerated(data: ConfigObject, inbounds: Inbound[]): ConfigObject {
  let next = data
  for (const inbound of inbounds) {
    const setup = readSetup(next, inbound.name)
    const mode = inbound.outbound
    if (!setup || mode.kind !== 'named' || mode.name !== proxyGroupName(inbound.name)) continue
    next = applySetup(next, inbound.name, setup)
  }
  return next
}

/** 面板上一个 tab 对应的策略组。 */
export interface PanelGroup {
  name: string
  /** tab 上显示什么。自己的组显示挑法，共用的组显示它自己的名字 */
  label: string
  /** 它从哪几个订阅取成员。测延迟要顺着来源找，见 web/runtime.ts 的 membersOf */
  uses: string[]
  /** 能不能点成员换选中 */
  pickable: boolean
}

/**
 * 这一路入站的面板上能操作哪些策略组。
 *
 * 只此一处回答这个问题。之前它散在四个地方（页面算一次能不能点、组件再算一次、
 * 共用与否又各算一次），加一种情况就要同时改四处，漏一处就是界面和实际操作对不上。
 *
 * 两种情况：接管过的入站是它自己那三个组；没接管的（比如 `mixed-port`，配置顶层的端口
 * 字段没有 `proxy` 可写）落到它顺着规则表走到的那个手动选择组上，那个组是共用的。
 */
export function panelGroups(
  data: ConfigObject,
  runtime: Record<string, RuntimeNode>,
  inbound: Inbound,
): { groups: PanelGroup[]; shared: boolean } {
  const mode = inbound.outbound
  const managed = mode.kind === 'named' && mode.name === proxyGroupName(inbound.name)

  if (managed) {
    return {
      shared: false,
      groups: ownGroups(inbound.name)
        // 保存完到内核重载完之间，组已经在配置里但运行时还没有，这时先不显示那个 tab
        .filter((g) => runtime[g.name])
        .map((g) => ({
          ...g,
          uses: groupUses(data, g.name) ?? [],
          // 只有手动选的那个能点。另外两个自己决定用哪条，理由见 outbound-chain.ts
          pickable: runtime[g.name]?.type === 'Selector',
        })),
    }
  }

  const chain = resolveChain(runtime, resolveDestination(data, inbound))
  const fallback = lastSwitchableGroup(runtime, chain)
  if (!fallback) return { groups: [], shared: false }
  return {
    shared: true,
    groups: [
      {
        name: fallback.group,
        label: fallback.group,
        uses: groupUses(data, fallback.group) ?? [],
        pickable: true,
      },
    ],
  }
}

/**
 * 筛选条件会留下哪些线路。界面上用来在保存前当场告诉用户「匹配到几条」。
 *
 * 照着内核的规则算（`adapter/outboundgroup/groupbase.go:72-76, 168-195`）：反引号把
 * 条件切成多条独立正则，取并集；每条都是部分匹配，不自动加锚点。
 *
 * 内核用的是支持前后向查找的 .NET 风味引擎，浏览器只有 JS 的，所以复杂写法这里算出来的
 * 数字可能和内核不一致。写法有误时返回 null，界面据此提示而不是显示一个错的数字。
 */
export function linesMatching(filter: string | null, lines: string[]): string[] | null {
  if (!filter) return lines
  let regexps: RegExp[]
  try {
    regexps = filter.split('`').map((part) => new RegExp(part))
  } catch {
    return null
  }
  return lines.filter((line) => regexps.some((re) => re.test(line)))
}