import * as _ from 'lodash'
import Teambition from '../../client/teambition'
import { IUApplicationModel } from '../../../model/application'
import { App, Context } from '../../../types'
import { IUProjectModel } from '../../../model/project'
import { IUCustomfieldModel } from '../../../model/customfield'
import { IUWorktimeModel } from '../../../model/worktime'

// 外援
export class ForeignAid {
  protected app: App
  protected ctx: Context

  constructor (app: App, ctx: Context) {
    this.app = app
    this.ctx = ctx
  }

  async getenableApplications(project: IUProjectModel) {
    const conds = { _boundToObjectId: project._id }
    const apprelation = await this.app.db.apprelation.findOne(conds).exec()
    if (!apprelation) {
      return []
    }

    const populateOpts = {
      path: 'applications._applicationId',
      select: '_id name type',
      match: {
        status: 'online'
      }
    }
    await apprelation.populate(populateOpts).execPopulate()
    const applications = _.reduce(
      apprelation.applications,
      function (apps, application) {
        if (!application._applicationId) {
          return apps
        }
        const { order } = application
        application = application._applicationId.toJSON()
        application.order = order
        apps.push(application)
        return apps
      },
      []
    )
    return applications
  }

  async getCustomfieldMap(project: IUProjectModel) {
    const customfieldsMap = new Map()
    const client = new Teambition(this.app, this.ctx)

    const customfields: IUCustomfieldModel[] = await client.getCutomfieldsByProjectId(project._id)

    customfields.forEach((customfield) => {
      customfieldsMap.set(`${customfield._id}`, customfield)
    })

    return customfieldsMap
  }

  async getScenariofieldsArray(projectId: string) {
    let newScenariofieldsArray = [] // 最终拿到的任务类型内字段数组(已去重)
    let scenariofieldsArray = [] // 存储scenariofields数组(未去重)
    const customfieldMap = new Map()

    const conds = {
      _boundToObjectId: projectId,
      objectType: 'task'
    }

    const scenariofieldconfigs = await this.app.db.scenariofieldconfig.find(conds).sort('created').lean().exec()

    scenariofieldconfigs.forEach((scenariofieldconfig) => {
      scenariofieldsArray = _.concat(
        scenariofieldsArray,
        scenariofieldconfig.scenariofields
      )
    })

    let count = 0

    // 去除重复的自定义字段
    scenariofieldsArray.forEach((scenariofieldsType) => {
      if (scenariofieldsType.fieldType === 'customfield') {
        if (customfieldMap.get(`${scenariofieldsType._customfieldId}`)) return
        scenariofieldsType.fieldType = `customfield${count}`
        customfieldMap.set(
          `${scenariofieldsType._customfieldId}`,
          scenariofieldsType
        )
        count++
        return newScenariofieldsArray.push(scenariofieldsType)
      }
      return newScenariofieldsArray.push(scenariofieldsType)
    })

    // 去除重复的官方字段
    newScenariofieldsArray = _.uniqBy(newScenariofieldsArray, 'fieldType')
    return newScenariofieldsArray
  }

  hasUniqueId(applications: IUApplicationModel[]) {
    return applications.some((application) => {
      return application.name === 'taskUniqueId'
    })
  }

  async getScenariofieldconfigMap(_projectId: string) {
    const scenariofieldconfigMap = new Map()
    const client = new Teambition(this.app, this.ctx)

    const scenariofieldconfigs = await client.getSfcByProjectId(
      _projectId,
      'task'
    )

    scenariofieldconfigs.forEach((scenariofieldconfig) => {
      scenariofieldconfigMap.set(
        `${scenariofieldconfig._id}`,
        scenariofieldconfig.name
      )
    })
    return scenariofieldconfigMap
  }

  getDefaultConfigByProjectIdObjectType(_projectId: string, objectType: string) {
    const conds = {
      _boundToObjectId: _projectId,
      objectType,
      type: 'default'
    }
    return this.app.db.scenariofieldconfig.findOne(conds).lean().exec()
  }

  /**
 * @memberof WorktimeBll
 * @author richardwei
 * @since 2017.09
 * @desc 获取带创建者信息的工时列表
 */
  async getWorkLogMap(taskIds: string[]): Promise<Map<string, IUWorktimeModel>> {
    const conds = {
      _taskId: {
        $in: taskIds
      },
      isDeleted: false
    }

    const worklogs:IUWorktimeModel[] = await this.app.db.worktime
    .find(conds)
    .sort('-created')
    .populate({
      path: '_executorId',
      select: 'name'
    })
    .lean()
    .exec()

    const map = new Map()
    worklogs.map((worklog) => {
      map.set(`${worklog._taskId}`, worklog)
    })

    return map
  }

  /**
   * @returns [ { _id: 'task', count: 2 }, { _id: 'work', count: 1 }]
   * @author jiangwei
   * @desc 统计任务关联的任务、日程、文件、分享的数量
   */
  getLinkCountByParentId(_parentId) {
    const cond = [
      {
        $match: {
          _parentId,
          linkedType: {
            $in: ['task', 'event', 'work', 'post', 'entry']
          },
          parentType: 'task',
          isDeleted: false
        }
      },
      {
        $unwind: '$linkedType'
      },
      {
        $sortByCount: '$linkedType'
      }
    ]
    return this.app.db.objectlink.aggregate(cond)
  }
}