import {
  DvaModelType,
  EntityMeta,
  IrsBrokerVoteDto,
  IrsPreconfigStateType,
  IrsRankStateType,
  IrsVoteStateType,
  ListedResponseEntity,
  ModelAction,
  Pagination,
  SearchQueryParams,
  SpecificationStateType,
} from '@amc-udk/types'
import { LoggerFactory, ObjectUtils, SearchSpecUtils } from '@amc-udk/utils'
import { EoConfiger, ICommonService } from '@amc-udk/uwp'
import { PreconfigUtils } from '../utils'

const namespace = 'vote'
const Logger = LoggerFactory.get(namespace)

export const IrsVoteModel: DvaModelType<IrsVoteStateType> = {
  namespace,
  effects: {
    /**
     * 查询已分评分列表
     * @param param0
     * @param param1
     * @returns
     */
    *getAllVoted({ type, payload = {} }: ModelAction<SearchQueryParams>, { select, call, put }) {
      const state = yield select(_ => _[namespace])
      const specsState: SpecificationStateType = yield select(_ => _.specification)
      const { voter }: IrsRankStateType = yield select(_ => _.rank)
      const [, action] = type.split('/')

      const searchSpecs = SearchSpecUtils.getSpecsFromState(specsState, namespace, action)
      if (payload && payload.searchSpecs) {
        // 将默认搜索条件附加
        payload.searchSpecs = [...searchSpecs, ...payload.searchSpecs]
      }

      // 查询实际派点值不为0的记录
      payload.searchSpecs.push({
        field: 'actualPoints',
        type: 'neq',
        value: 0,
        valueType: 'number',
        conjunct: 'and',
      })
      payload.searchSpecs.push({
        field: 'receiver',
        type: 'eq',
        value: voter,
        valueType: 'string',
        conjunct: 'and',
      })
      try {
        const resp: ListedResponseEntity<any> = yield call(
          EoConfiger.getService<ICommonService>().post,
          state.url.concat('/all'),
          payload,
          true,
        )
        let eos: any[] = []
        if (resp && resp.success) {
          eos = resp.data.filter(x => !!x)
        }
        if (eos.length > 0) {
          yield put({
            type: 'updateState',
            payload: {
              voted: ObjectUtils.fromEntries(eos, 'id'),
            },
          })
        }
      } catch (e) {
        EoConfiger.getAlert().alert('error', type, '获取全部已打分记录失败！')
      }
    },

    /**
     * 查询已分评分列表
     * @param param0
     * @param param1
     * @returns
     */
    *getAllUnvoted({ type, payload = {} }: ModelAction<SearchQueryParams>, { select, call, put }) {
      const state = yield select(_ => _[namespace])
      const specsState: SpecificationStateType = yield select(_ => _.specification)
      const { voter }: IrsRankStateType = yield select(_ => _.rank)
      const [, action] = type.split('/')

      const searchSpecs = SearchSpecUtils.getSpecsFromState(specsState, namespace, action)
      if (payload && payload.searchSpecs) {
        // 将默认搜索条件附加
        payload.searchSpecs = [...searchSpecs, ...payload.searchSpecs]
      }

      // 查询实际派点值不为0的记录
      payload.searchSpecs.push({
        field: 'status',
        type: 'isNull',
        value: '0',
        valueType: 'string',
        conjunct: 'and',
      })
      payload.searchSpecs.push({
        field: 'receiver',
        type: 'eq',
        value: voter,
        valueType: 'string',
        conjunct: 'and',
      })
      try {
        const resp: ListedResponseEntity<any> = yield call(
          EoConfiger.getService<ICommonService>().post,
          state.url.concat('/all'),
          payload,
          true,
        )
        let eos: any[] = []
        if (resp && resp.success) {
          eos = resp.data.filter(x => !!x)
        }
        if (eos) {
          yield put({
            type: 'postProcessAllData',
            payload: {
              data: eos,
            },
          })
        }
      } catch (e) {
        EoConfiger.getAlert().alert('error', type, '获取全部已打分记录失败！')
      }
    },

    *postProcessListData(
      { type, payload }: ModelAction<{ list: IrsBrokerVoteDto[]; pagination: Pagination }>,
      { select, call, put },
    ) {
      if (!payload || !payload.list) {
        return
      }
      if (!Array.isArray(payload.list)) {
        return Logger.error('无法处理非数组类全量数据！')
      }

      const { users }: IrsPreconfigStateType = yield select(_ => _.preconfig)

      payload.list.forEach(dto => {
        const key = PreconfigUtils.createPrimaryKey(dto.serviceType, dto.ifCustomed, dto.receiver)
        // 如果当前服务记录的打分和预评分值未定义，则根据预评分设置，填入对应的值
        if (users[key]) {
          dto.preVotePoints = users[key]
          if (dto.actualPoints === undefined) {
            dto.actualPoints = users[key]
          }
        }
      })

      yield put({
        type: 'updateState',
        payload,
      })
    },

    *postProcessAllData(
      { type, payload }: ModelAction<{ meta: EntityMeta; data: IrsBrokerVoteDto[] }>,
      { select, call, put },
    ) {
      if (!payload || !payload.data) {
        return
      }
      if (!Array.isArray(payload.data)) {
        return Logger.error('无法处理非数组类全量数据！')
      }

      const { voter }: IrsRankStateType = yield select(_ => _.rank)

      const { users: usersPreconfig }: IrsPreconfigStateType = yield select(_ => _.preconfig)
      const { users: usersMaxPoints }: IrsPreconfigStateType = yield select(_ => _.points)

      let availablePoints = 0
      if (usersMaxPoints[voter]) {
        availablePoints = usersMaxPoints[voter]
      }
      const preVotePoints = payload.data.reduce((prev, curr) => {
        const key = PreconfigUtils.createPrimaryKey(
          curr.serviceType,
          curr.ifCustomed,
          curr.receiver,
        )

        const preVotePoint = usersPreconfig[key] === undefined ? 0 : usersPreconfig[key]
        return prev + preVotePoint
      }, 0)

      payload.data.forEach(dto => {
        if (dto.actualPoints === undefined) {
          const key = PreconfigUtils.createPrimaryKey(dto.serviceType, dto.ifCustomed, dto.receiver)
          // 如果当前服务记录的打分和预评分值未定义，则根据预评分设置，填入对应的值

          if (usersPreconfig[key] && preVotePoints > 0) {
            dto.preVotePoints = usersPreconfig[key]
            dto.actualPoints = (usersPreconfig[key] * availablePoints) / preVotePoints
          }
        }

        // if (dto.preVotePoints === undefined && dto.actualPoints === undefined) {

        // }
        // if (users[key]) {
        //   dto.preVotePoints = users[key]
        //   if (dto.actualPoints === undefined) {
        //     dto.actualPoints = users[key]
        //   }
        // }
      })

      yield put({
        type: 'updateState',
        payload: {
          all: payload.data,
        },
      })
    },
  },
}