import { create } from 'zustand'

const useBearStore = create((set) => ({
  bears: 0,
  increasePopulation: () => set((state) => ({ bears: state.bears + 1 })),
  removeAllBears: () => set({ bears: 0 }),
}))

class BearCounter extends React.Component {
  componentDidMount() {
    this.unSub = useBearStore.subscribe(this.handleSubscribe)
  }

  componentWillUnmount() {
    this.unSub()
  }

  handleSubscribe = (store) => {
    this.setState({ bears: store.bears })
  }

  render() {
    const { bears } = this.state
    return <h1>{bears} around here ...</h1>
  }
}

const createStoreImpl: CreateStoreImpl = (createState) => {
  type TState = ReturnType<typeof createState>
  type Listener = (state: TState, prevState: TState) => void
  // 闭包记录 state
  let state: TState
  // 记录订阅的数组
  const listeners: Set<Listener> = new Set()
  // 更新 state ，触发事件监听，state 支持函数更新
  const setState: StoreApi<TState>['setState'] = (partial, replace) => {
    const nextState =
      typeof partial === 'function'
        ? (partial as (state: TState) => TState)(state)
        : partial
    if (!Object.is(nextState, state)) {
      const previousState = state
      state =
        replace ?? (typeof nextState !== 'object' || nextState === null)
          ? (nextState as TState)
          : Object.assign({}, state, nextState)
      listeners.forEach((listener) => listener(state, previousState))
    }
  }

  // 获取 state 状态
  const getState: StoreApi<TState>['getState'] = () => state

  // 获取初始化状态
  const getInitialState: StoreApi<TState>['getInitialState'] = () =>
    initialState

  // 订阅状态更新，返回移除事件监听
  const subscribe: StoreApi<TState>['subscribe'] = (listener) => {
    listeners.add(listener)
    // Unsubscribe
    return () => listeners.delete(listener)
  }

  const api = { setState, getState, getInitialState, subscribe }
  // 初始化 state
  const initialState = (state = createState(setState, getState, api))
  return api as any
}

export function useStore<TState, StateSlice>(
  api: ReadonlyStoreApi<TState>,
  selector: (state: TState) => StateSlice = identity as any
) {
  // 订阅更新，通过 selector 获取对应的数据
  const slice = React.useSyncExternalStore(
    api.subscribe,
    () => selector(api.getState()),
    () => selector(api.getInitialState())
  )
  // debug 时使用，输出 store 数据
  React.useDebugValue(slice)
  return slice
}

const reduxImpl = (reducer, initial) => (set, _get, api) => {
  // 实现 dispatch
  api.dispatch = (action) => {
    set((state) => reducer(state, action), false, action)
    return action
  }
  // 标识来源，目前主要用于 devtools 中
  api.dispatchFromDevtools = true

  return { dispatch: (...a) => api.dispatch(...a), ...initial }
}

// test.ts
export function test() {
  console.log('hello world')
}

// test.ts
namespace Test {
  export function test() {
    console.log('hello world')
  }
}

// 使用时
/// <reference path="test.ts" />
Test.test()

const test: any = 'sss'
if (typeof test === 'string') {
  // string 类型时
}

// 函数
interface Fun {
  (a: number): void
}

// 数组
interface Arr {
  [index: number]: string
}

function classDecorater<T extends { new (...args: any): {} }>(constructor: T) {
  return class extends constructor {
    public test = 'xxxx'
  }
}

@classDecorater
class Test {
  public aaa = 'aaa'
}

function propDecorater() {
  return function (obj: any, key: string, config: PropertyDescriptor) {
    // 装饰器逻辑
    console.log('obj', obj, 'key', key, 'config', config)
  }
}

class Test {
  @propDecorater()
  aaa: string
}

type MyExclude<T, K> = T extends K ? never : T

type MyInclude<T, K> = T extends K ? T : never

type MyOmit<T extends Object, K> = Pick<T, Exclude<keyof T, K>>

type MyPartial<T extends Object> = { [K in keyof T]?: T[K] }

type MyPick<T extends Object, K> = {
  [M in MyInclude<keyof T, K>]: T[M]
}

type MyRequired<T> = { [K in keyof T]-?: T[K] }

type MyParameters<T extends (arg: any) => any> = T extends (arg: infer K) => any
  ? K
  : never

type MyConstructorParameters<T extends abstract new(arg: any): any > = T extends abstract new(arg: infer K): any ? K : never

type MyReturnType<T extends (arg: any) => any> = T extends (arg: any) => infer K
  ? K
  : never

function getPropType<T, K extends keyof T>(obj: T, key: K) {
  return obj[key]
}

type NotNull<T> = T extends null | undefined ? never : T

function call<T extends `aaa_${string}`>(a: T) {
  console.log('aa', a)
}

call('xxx') // Argument of type '"xxx"' is not assignable to parameter of type '`aaa_${string}`'.

type test<T extends number> = `${T}` extends `-${infer M}` ? never : T

function testCall<T extends number>(a: test<T>) {
  console.log('testCall', a)
}

testCall(-1) // Argument of type 'number' is not assignable to parameter of type 'never'.