import type {
  IObservable,
  TNonFunctionProperties,
  TObservableKeyListener,
  TObservableListener,
  TObservableState,
} from '@/core/state/IObservable.ts'

/**
 * 创建一个可观察对象，用于管理状态和事件。
 * @template T - 需要处理的状态类型
 * @example
 * interface Todos {
 *   id: number
 *   text: string
 *   done: boolean
 * }
 *
 * interface AppState {
 *   count: number
 *   todos: Todos[]
 *   user: {
 *     name: string
 *     age: number
 *   }
 *   inc(): void
 * }
 *
 * const obs = new ObservableImpl<AppState>({
 *   count: 0,
 *   todos: [],
 *   user: { name: "Alice", age: 20 },
 *   inc() {
 *     this.count++ // ✅ this 指向 obs.state
 *   },
 * })
 *
 * // ================== 使用示例 ==================
 *
 * // 1. 订阅整个 state
 * obs.subscribe(state => {
 *   console.log("[全量订阅] state 更新:", state)
 * })
 *
 * // 2. 订阅单个字段
 * obs.subscribeKey("count", ({ count }) => {
 *   console.log("[字段订阅] count 更新:", count)
 * })
 *
 * // 3. 订阅多个字段
 * obs.subscribeKey(["name", "age"] as (keyof AppState["user"])[], (user) => {
 *   console.log("[多字段订阅] user 更新:", user)
 * })
 *
 * // 4. 批量更新
 * obs.patch({ count: 10, user: { name: "Bob", age: 30 } })
 *
 * // 5. 方法里操作 state
 * obs.state.inc() // this.count++ → 相当于 obs.state.count++
 *
 * // 6. 数组操作
 * obs.subscribeKey("todos", ({ todos }) => {
 *   console.log("[数组订阅] todos 更新:", todos.map(t => t.text))
 * })
 *
 * obs.state.todos.push({ id: 1, text: "Buy milk", done: false })
 * obs.state.todos.push({ id: 2, text: "Read book", done: false })
 * obs.state.todos[0].done = true
 *
 * // 7. 嵌套对象
 * obs.subscribeKey("user", ({ user }) => {
 *   console.log("[嵌套订阅] user 更新:", user)
 * })
 *
 * obs.state.user.age++
 */
export class ObservableImpl<T extends TNonFunctionProperties<T>> implements IObservable<T> {
  /** Observable 状态对象，深层 Proxy */
  public readonly state: TObservableState<T>

  /** 全量订阅函数集合 */
  private listeners: Set<TObservableListener<T>> = new Set()

  /** 字段订阅函数集合 */
  private keyListeners: Map<keyof T, Set<TObservableKeyListener<T, keyof T>>> = new Map()

  /** 待通知的字段集合 */
  private pendingKeys: Set<keyof T> = new Set()

  /** 是否已经安排通知 */
  private notifyScheduled = false

  /** 是否已销毁 */
  private disposed = false

  /** 缓存 Proxy，避免重复包装 */
  private proxyCache: WeakMap<object, TObservableState<unknown>> = new WeakMap()

  constructor(initialState: TNonFunctionProperties<T>) {
    // 创建深层响应式 Proxy
    this.state = this.makeReactive(initialState) as TObservableState<T>
  }

  /** 创建深层 Proxy，拦截 get/set/delete，并自动缓存 */
  private makeReactive<O extends object>(obj: O): TObservableState<O> {
    // 非对象直接返回（包括 null 已被排除）
    if (typeof obj !== "object" || obj === null) {
      return obj as unknown as TObservableState<O>
    }

    // 如果已有 Proxy 缓存则直接返回
    const cached = this.proxyCache.get(obj as object)
    if (cached !== undefined) {
      return cached as TObservableState<O>
    }

    const handler: ProxyHandler<O> = {
      get: (target, prop, receiver) => {
        const value = Reflect.get(target, prop, receiver) as unknown
        // 不包装函数
        if (typeof value === "function") {
          return value
        }
        // 对对象/数组继续进行响应式包装（递归）
        if (typeof value === "object" && value !== null) {
          return this.makeReactive(value as object)
        }
        return value
      },

      set: (target, prop, value, receiver) => {
        // 读取旧值（使用 Record 以便类型安全访问属性）
        const oldValue = (target as Record<PropertyKey, unknown>)[prop as PropertyKey] as unknown
        const result = Reflect.set(target, prop, value as unknown, receiver)
        // 仅在值改变时触发通知（基于引用/原始值比较）
        if (!this.disposed && oldValue !== (value as unknown)) {
          this.pendingKeys.add(prop as keyof T)
          this.scheduleNotify()
        }
        return result
      },

      deleteProperty: (target, prop) => {
        if (prop in target) {
          // 使用 Reflect.deleteProperty 以保持一致性
          const deleted = Reflect.deleteProperty(target, prop)
          if (deleted && !this.disposed) {
            this.pendingKeys.add(prop as keyof T)
            this.scheduleNotify()
          }
          return deleted
        }
        return false
      }
    }

    const proxy = new Proxy(obj, handler) as TObservableState<O>
    this.proxyCache.set(obj as object, proxy as TObservableState<unknown>)
    return proxy
  }

  /** 安排下一次通知（微任务合并） */
  private scheduleNotify(): void {
    if (!this.notifyScheduled && !this.disposed) {
      this.notifyScheduled = true
      Promise.resolve().then(() => this.flushNotify())
    }
  }

  /** 执行通知（聚合字段订阅并保证错误隔离） */
  private flushNotify(): void {
    if (this.disposed) return

    const keys = Array.from(this.pendingKeys)
    this.pendingKeys.clear()
    this.notifyScheduled = false

    // 全量订阅 —— 每个订阅单独 try/catch，避免一个错误阻塞其它订阅
    for (const fn of this.listeners) {
      try {
        fn(this.state as unknown as T)
      } catch (err) {
        // 可以根据需要把错误上报或自定义处理
        // 这里简单打印以便调试
        // eslint-disable-next-line no-console
        console.error("Observable listener error:", err)
      }
    }

    // 字段订阅：把同一个回调的多个 key 聚合到一次调用里
    const fnMap: Map<TObservableKeyListener<T, keyof T>, Array<keyof T>> = new Map()
    for (const key of keys) {
      const set = this.keyListeners.get(key)
      if (!set) continue
      for (const fn of set) {
        const existing = fnMap.get(fn)
        if (existing === undefined) {
          fnMap.set(fn, [key])
        } else {
          existing.push(key)
        }
      }
    }

    // 调用每个字段订阅回调
    fnMap.forEach((subKeys, fn) => {
      try {
        // 构造 Pick<T, K> 风格的结果对象：结果类型为 Pick<T, (typeof subKeys)[number]>
        const result = {} as Pick<T, (typeof subKeys)[number]>
        subKeys.forEach(k => {
          // 这里断言原因：state 的索引访问返回 unknown，但我们把它赋回到受限的 Pick 上
          result[k] = (this.state as Record<keyof T, unknown>)[k] as T[(typeof k) & keyof T]
        })
        // 调用时类型上兼容 TObservableKeyListener<T, K>，因为我们传的是对应 key 的 Pick
        fn(result as Pick<T, (typeof subKeys)[number]>)
      } catch (err) {
        // eslint-disable-next-line no-console
        console.error("Observable keyListener error:", err)
      }
    })
  }

  /** 订阅整个状态变化 */
  public subscribe(fn: TObservableListener<T>, options: { immediate?: boolean } = {}): () => void {
    this.listeners.add(fn)
    if (options.immediate) {
      try {
        fn(this.state as unknown as T)
      } catch (err) {
        // eslint-disable-next-line no-console
        console.error("Observable subscribe immediate error:", err)
      }
    }
    return () => {
      this.listeners.delete(fn)
    }
  }

  /** 订阅指定字段变化 */
  public subscribeKey<K extends keyof T>(
    keys: K | K[],
    fn: TObservableKeyListener<T, K>,
    options: { immediate?: boolean } = {}
  ): () => void {
    const keyArray = Array.isArray(keys) ? keys : [keys]
    for (const key of keyArray) {
      if (!this.keyListeners.has(key)) this.keyListeners.set(key, new Set())
      // 存储为 Set<TObservableKeyListener<T, keyof T>>
      this.keyListeners.get(key)!.add(fn as TObservableKeyListener<T, keyof T>)
    }

    if (options.immediate) {
      const result = {} as Pick<T, K>
      keyArray.forEach(k => {
        result[k] = (this.state as Record<keyof T, unknown>)[k] as T[K]
      })
      try {
        fn(result)
      } catch (err) {
        // eslint-disable-next-line no-console
        console.error("Observable subscribeKey immediate error:", err)
      }
    }

    return () => {
      for (const key of keyArray) {
        this.keyListeners.get(key)?.delete(fn as TObservableKeyListener<T, keyof T>)
      }
    }
  }

  /** 批量更新状态（避免重复 schedule） */
  public patch(values: Partial<T>): void {
    let changed = false
    // 用 for..in 保持和对象字面量兼容（跳过原型链）
    for (const key in values) {
      if (Object.prototype.hasOwnProperty.call(values, key)) {
        const typedKey = key as keyof T
        const oldValue = (this.state as Record<keyof T, unknown>)[typedKey]
        const newValue = values[typedKey] as unknown
        if (oldValue !== newValue) {
          // 直接写入 state，会被 Proxy 的 set 捕获并安排通知
          ;(this.state as Record<keyof T, unknown>)[typedKey] = newValue
          changed = true
        }
      }
    }
    // 如果至少有一处变化，安排一次通知（如果写入已由 set 调度过也不会重复安排）
    if (changed) this.scheduleNotify()
  }

  /** 销毁 Observable 实例 */
  public dispose(): void {
    this.disposed = true
    this.listeners.clear()
    this.keyListeners.clear()
    this.pendingKeys.clear()
    this.proxyCache = new WeakMap()
    Object.freeze(this.state)
  }

  /** 语法糖：返回一个可解构赋值的 Proxy */
  public toRefsProxy(): { [K in keyof T]: T[K] } {
    const self = this
    return new Proxy({} as { [K in keyof T]: T[K] }, {
      get(_, prop: string | symbol) {
        const key = prop as keyof T
        return (self.state as Record<keyof T, unknown>)[key] as T[typeof key]
      },
      set(_, prop: string | symbol, value) {
        const key = prop as keyof T
        ;(self.state as Record<keyof T, unknown>)[key] = value as unknown
        return true
      },
      ownKeys() {
        return Reflect.ownKeys(self.state)
      },
      getOwnPropertyDescriptor(_, _prop: string | symbol) {
        return { enumerable: true, configurable: true }
      }
    })
  }
}