import requestMethod from '../../../../api/dynamic/table'
import { ColumnsProps, SearchProps } from '../../../../components/table/table-helper'
import { FieldProps, FieldType } from '../../../../components/form-item/field-props'
import { QueryObjectType, QueryType } from '../../../../http/request-model'
import dictionaryRequestMethod from '../../../../api/system/dictionary'
import dynamicRecordRequestMethod from '../../../../api/dynamic/record'
import { DynamicFormTableColumnVo } from '../../../../entity/dynamic/dynamic-form-table'

const COLUMN_TYPE_MAP: { [key: string]: FieldType } = {
	varchar: 'input',
	text: 'textarea',
	int: 'input-number',
	datetime: 'date-picker',
	date: 'date-picker'
}

const SEARCH_COLUMN_TYPE_MAP: { [key: string]: string } = {
	varchar: 'text',
	int: 'number',
	text: 'text',
	datetime: 'date-time-picker',
	date: 'date-picker',
	time: 'time-picker'
}

export interface ShowTableField {
	tableId: string
	showFieldName: string
	columnName: string
}

type DictionaryKeyMapType = { [key: string]: string }

type DictionaryMapType = { [key: string]: DictionaryKeyMapType }

export default async function (
	id: string,
	code: string
): Promise<
	Required<{
		// 列表显示字段信息
		tableColumnList: ColumnsProps<unknown>[]
		// 表单显示字段信息
		formFieldList: FieldProps[]
		// 查询显示字段信息
		searchFieldList: SearchProps[]
		// tableId
		tableId: string
		// 表名称
		tableName: string
		// 数据字典id列表
		dictionaryIdMap: DictionaryKeyMapType
		// 需要加载的动态表单信息
		showTableFieldList: ShowTableField[]
	}>
> {
	// 获取数据表信息
	const resultModel = await (id ? requestMethod.getById(id) : requestMethod.getByCode(code))
	const columnList = resultModel.data.columnList
	// 需要加载的动态表单信息
	const showTableFieldList = getShowTableFieldList(columnList)
	// 查询出所有的表信息
	const tableRecordMap = await getTableRecordMap(showTableFieldList)
	// 数据字典信息
	const dictionaryIdMap = getDictionaryIdMap(columnList)
	// 获取需要的数据字典信息
	const dictionaryMap = await getDictionaryMap(dictionaryIdMap)

	return {
		dictionaryIdMap,
		tableId: resultModel.data.id,
		tableName: resultModel.data.tableComment,
		// 列表显示字段信息
		tableColumnList: buildTableColumnList(columnList, dictionaryMap, tableRecordMap),
		// 表单显示字段信息
		formFieldList: buildFormFieldList(columnList),
		// 查询显示字段信息
		searchFieldList: buildSearchFieldList(columnList),
		showTableFieldList
	}
}

/**
 * 获取数据字典id信息
 * @param columnList
 */
const getDictionaryIdMap = (columnList: Array<DynamicFormTableColumnVo>): DictionaryKeyMapType => {
	const dictionaryIdMap: DictionaryKeyMapType = {}
	columnList
		.filter(item => item.columnKeyType == 4)
		.forEach(item => {
			dictionaryIdMap[item.columnName] = item.columnKeyId
		})
	return dictionaryIdMap
}

/**
 * 获取数据字典的信息
 * @param dictionaryIdMap
 */
const getDictionaryMap = async (dictionaryIdMap: { [key: string]: string }): Promise<DictionaryMapType> => {
	return new Promise(resolve => {
		const dictionaryMap: { [key: string]: { [key: string]: string } } = {}
		Object.entries(dictionaryIdMap).forEach(async ([columnName, dictionaryId]) => {
			const resultModel = await dictionaryRequestMethod.getListRootCode(dictionaryId)
			if (!dictionaryMap[columnName]) {
				dictionaryMap[columnName] = {}
			}
			resultModel.data.forEach(item => (dictionaryMap[columnName][item.id] = item.itemName))
		})
		resolve(dictionaryMap)
	})
}

/**
 * 获取动态表的数据
 * @param showTableFieldList
 */
const getTableRecordMap = async (showTableFieldList: ShowTableField[]): Promise<DictionaryMapType> => {
	return new Promise(resolve => {
		const dictionaryMap: { [key: string]: { [key: string]: string } } = {}
		showTableFieldList.forEach(item => {
			dynamicRecordRequestMethod.listBySelectField(item.tableId, item.showFieldName).then(data => {
				const keyItem = item.showFieldName + item.tableId
				if (!dictionaryMap[keyItem]) {
					dictionaryMap[keyItem] = {}
				}
				Object.entries(data.data).forEach(([key, value]) => (dictionaryMap[keyItem][key] = value))
			})
		})
		resolve(dictionaryMap)
	})
}

/**
 * 列表显示字段信息
 * @param columnList
 * @param dictionaryMap
 * @param tableRecordMap
 */
const buildTableColumnList = (
	columnList: Array<DynamicFormTableColumnVo>,
	dictionaryMap: DictionaryMapType,
	tableRecordMap: DictionaryMapType
): ColumnsProps<unknown>[] => {
	return columnList
		.slice()
		.filter(column => column.showType == 1 || column.showType == 2)
		.map(column => {
			if (column.columnKeyType == 4) {
				return {
					title: column.columnComment,
					dataIndex: column.columnName,
					customRender: ({ text }) => (dictionaryMap[column.columnName] ? dictionaryMap[column.columnName][text] : '')
				}
			} else if (column.columnKeyType == 3) {
				return {
					title: column.columnComment,
					dataIndex: column.columnName,
					customRender: ({ text }) =>
						tableRecordMap[column.showTextField + column.columnKeyId] ? tableRecordMap[column.showTextField + column.columnKeyId][text] : ''
				}
			}
			return {
				title: column.columnComment,
				dataIndex: column.columnName
			}
		}) as ColumnsProps<unknown>[]
}

/**
 * 表单显示字段信息
 * @param columnList
 */
const buildFormFieldList = (columnList: Array<DynamicFormTableColumnVo>): FieldProps[] => {
	return columnList
		.slice()
		.filter(column => column.showType == 1 || column.showType == 3)
		.map(column => {
			const typeFlag = column.columnKeyType == 4 || column.columnKeyType == 3
			return {
				name: column.columnName,
				label: column.columnComment,
				type: typeFlag ? 'select' : COLUMN_TYPE_MAP[column.columnType] || 'input',
				placeholder: `请填入${column.columnComment}`
			}
		}) as FieldProps[]
}

/**
 * 查询显示字段信息
 * @param columnList
 */
const buildSearchFieldList = (columnList: Array<DynamicFormTableColumnVo>): SearchProps[] => {
	return columnList
		.slice()
		.filter(column => column.searchType == 1 || column.searchType == 2 || column.searchType == 3)
		.map(column => {
			const type = SEARCH_COLUMN_TYPE_MAP[column.columnType] || 'text'
			if (column.searchType == 3) {
				return {
					type,
					field: column.columnName,
					label: column.columnComment,
					value: ['', ''],
					span: 5,
					placeholder: `请填入查询的${column.columnComment}`,
					options: {
						range: true
					},
					beforeArrayGet(value: unknown[]): QueryType {
						return {
							[`${column.columnName}Start`]: value[0] || '',
							[`${column.columnName}End`]: value[1] || ''
						} as QueryObjectType
					}
				}
			}
			return {
				type,
				field: column.columnName,
				label: column.columnComment,
				value: '',
				span: 5,
				placeholder: `请填入查询的${column.columnComment}`
			}
		}) as SearchProps[]
}

/**
 * 表单上显示的动态表信息
 * @param columnList
 */
const getShowTableFieldList = (columnList: Array<DynamicFormTableColumnVo>): ShowTableField[] => {
	return columnList
		.filter(column => column.columnKeyType == 3)
		.map(column => ({
			tableId: column.columnKeyId,
			showFieldName: column.showTextField,
			columnName: column.columnName
		})) as ShowTableField[]
}

// 修改表单信息