/*
 * SPDX-FileCopyrightText: syuilo and misskey-project
 * SPDX-License-Identifier: AGPL-3.0-only
 */

import { CALL_HURO_TYPES, CHAR_TILES, FourMentsuOneJyantou, House, MANZU_TILES, PINZU_TILES, SOUZU_TILES, TileType, YAOCHU_TILES, TILE_TYPES, analyzeFourMentsuOneJyantou, isShuntu, isManzu, isPinzu, isSameNumberTile, isSouzu, isKotsu, includes, TERMINAL_TILES, mentsuEquals, Huro, TILE_ID_MAP } from './common.js';
import { calcWaitPatterns, isRyanmen, isToitsu, FourMentsuOneJyantouWithWait } from './common.fu.js';

const RYUISO_TILES: TileType[] = ['s2', 's3', 's4', 's6', 's8', 'hatsu'];
const KOKUSHI_TILES: TileType[] = ['m1', 'm9', 'p1', 'p9', 's1', 's9', 'e', 's', 'w', 'n', 'haku', 'hatsu', 'chun'];

export const NORMAL_YAKU_NAMES = [
	'riichi',
	'ippatsu',
	'tsumo',
	'tanyao',
	'pinfu',
	'iipeko',
	'field-wind-e',
	'field-wind-s',
	'field-wind-w',
	'field-wind-n',
	'seat-wind-e',
	'seat-wind-s',
	'seat-wind-w',
	'seat-wind-n',
	'white',
	'green',
	'red',
	'rinshan',
	'chankan',
	'haitei',
	'hotei',
	'sanshoku-dojun',
	'sanshoku-doko',
	'ittsu',
	'chanta',
	'chitoitsu',
	'toitoi',
	'sananko',
	'honroto',
	'sankantsu',
	'shosangen',
	'double-riichi',
	'honitsu',
	'junchan',
	'ryampeko',
	'chinitsu',
	'dora',
	'red-dora',
] as const;

export const YAKUMAN_NAMES = [
	'kokushi',
	'kokushi-13',
	'suanko',
	'suanko-tanki',
	'daisangen',
	'tsuiso',
	'shosushi',
	'daisushi',
	'ryuiso',
	'chinroto',
	'sukantsu',
	'churen',
	'churen-9',
	'tenho',
	'chiho',
] as const;

type NormalYakuName = typeof NORMAL_YAKU_NAMES[number];

type YakumanName = typeof YAKUMAN_NAMES[number];

export type YakuName = NormalYakuName | YakumanName;

type Pon = {
	type: 'pon';
	tile: TileType;
};

type Cii = {
	type: 'cii';
	tiles: [TileType, TileType, TileType];
};

type Ankan = {
	type: 'ankan';
	tile: TileType;
};

type Minkan = {
	type: 'minkan';
	tile: TileType;
};

export type HuroForCalcYaku = Pon | Cii | Ankan | Minkan;

export type EnvForCalcYaku = {
	/**
	 * 和了る人の手牌(副露牌は含まず、ツモ、ロン牌は含む)
	 */
	handTiles: TileType[];

	/**
	 * 河
	 */
	hoTiles?: TileType[];

	/**
	 * 副露
	 */
	huros: HuroForCalcYaku[];

	/**
	 * 場風
	 */
	fieldWind?: House;

	/**
	 * 自風
	 */
	seatWind?: House;

	/**
	 * 局が始まってから誰の副露もない一巡目かどうか
	 */
	firstTurn?: boolean;

	/**
	 * リーチしたかどうか
	 */
	riichi?: boolean;

	/**
	 * 誰の副露もない一巡目でリーチしたかどうか
	 */
	doubleRiichi?: boolean;

	/**
	 * リーチしてから誰の副露もない一巡目以内かどうか
	 */
	ippatsu?: boolean;
} & ({
	tsumoTile: TileType;
	ronTile?: null;

	/**
	 * 嶺上牌のツモか
	 */
	rinshan?: boolean;

	/**
	 * 海底牌か
	 */
	haitei?: boolean;
} | {
	tsumoTile?: null;
	ronTile: TileType;

	/**
	 * 河底牌か
	 */
	hotei?: boolean;
});

interface YakuDataBase {
	name: YakuName;
	upper?: YakuName | null;
	fan?: number | null;
	isYakuman?: boolean;
}

interface NormalYakuData extends YakuDataBase {
	name: NormalYakuName;
	fan: number;
	isYakuman?: false;
	kuisagari?: boolean;
}

interface YakumanData extends YakuDataBase {
	name: YakumanName;
	isYakuman: true;
	isDoubleYakuman?: boolean;
}

export type YakuData = Required<NormalYakuData> | Required<YakumanData>;

abstract class YakuSetBase<IsYakuman extends boolean> {
	public readonly isYakuman: IsYakuman;

	public readonly yakus: YakuData[];

	public get yakuNames(): YakuName[] {
		return this.yakus.map(yaku => yaku.name);
	}

	constructor(isYakuman: IsYakuman, yakus: YakuData[]) {
		this.isYakuman = isYakuman;
		this.yakus = yakus;
	}
}

class NormalYakuSet extends YakuSetBase<false> {
	public readonly isMenzen: boolean;

	public readonly fan: number;

	constructor(isMenzen: boolean, yakus: Required<NormalYakuData>[]) {
		super(false, yakus);
		this.isMenzen = isMenzen;
		this.fan = yakus.reduce((fan, yaku) => fan + (!isMenzen && yaku.kuisagari ? yaku.fan - 1 : yaku.fan), 0);
	}
}

class YakumanSet extends YakuSetBase<true> {
	/**
	 * 何倍役満か
	 */
	public readonly value: number;

	constructor(yakus: Required<YakumanData>[]) {
		super(true, yakus);
		this.value = yakus.reduce((value, yaku) => value + (yaku.isDoubleYakuman ? 2 : 1), 0);
	}
}

export type YakuSet = NormalYakuSet | YakumanSet;

type YakuDefinitionBase = {
	calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantouWithWait | null) => boolean;
};

type NormalYakuDefinition = YakuDefinitionBase & NormalYakuData;

type YakumanDefinition = YakuDefinitionBase & YakumanData;

function countTiles(tiles: TileType[], target: TileType): number {
	return tiles.filter(t => t === target).length;
}

class Yakuhai implements NormalYakuDefinition {
	readonly name: NormalYakuName;

	readonly fan = 1;

	readonly isYakuman = false;

	readonly tile: typeof CHAR_TILES[number];

	constructor(name: NormalYakuName, house: typeof CHAR_TILES[number]) {
		this.name = name;
		this.tile = house;
	}

	calc(state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null): boolean {
		if (fourMentsuOneJyantou == null) return false;

		return (
			(countTiles(state.handTiles, this.tile) >= 3) ||
			(state.huros.some(huro =>
				huro.type === 'pon' ? huro.tile === this.tile :
				huro.type === 'ankan' ? huro.tile === this.tile :
				huro.type === 'minkan' ? huro.tile === this.tile :
				false))
		);
	}
}

class FieldWind extends Yakuhai {
	calc(state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null): boolean {
		return super.calc(state, fourMentsuOneJyantou) && state.fieldWind === this.tile;
	}
}

class SeatWind extends Yakuhai {
	calc(state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null): boolean {
		return super.calc(state, fourMentsuOneJyantou) && state.seatWind === this.tile;
	}
}

/**
 * 2つの同じ面子の組を数える (一盃口なら1、二盃口なら2)
 */
function countIndenticalMentsuPairs(mentsus: [TileType, TileType, TileType][]) {
	let result = 0;
	const singleMentsus: [TileType, TileType, TileType][] = [];
	loop: for (const mentsu of mentsus) {
		for (let i = 0; i < singleMentsus.length; i++) {
			if (mentsuEquals(mentsu, singleMentsus[i])) {
				result++;
				singleMentsus.splice(i, 1);
				continue loop;
			}
		}
		singleMentsus.push(mentsu);
	}
	return result;
}

/**
 * 暗刻の数を数える (三暗刻なら3、四暗刻なら4)
 */
function countAnkos(state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantouWithWait) {
	const ankans = state.huros.filter(huro => huro.type === 'ankan').length;
	const handKotsus = fourMentsuOneJyantou.mentsus.filter(mentsu => isKotsu(mentsu)).length;

	// ロンによりできた刻子は暗刻ではない
	if (state.ronTile != null && fourMentsuOneJyantou.waitedFor === 'mentsu' && isToitsu(fourMentsuOneJyantou.waitedTaatsu)) {
		return ankans + handKotsus - 1;
	}

	return ankans + handKotsus;
}

export const NORMAL_YAKU_DEFINITIONS: NormalYakuDefinition[] = [
	{
		name: 'tsumo',
		fan: 1,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
		// 門前じゃないとダメ
			if (state.huros.some(huro => includes(CALL_HURO_TYPES, huro.type))) return false;

			return state.tsumoTile != null;
		},
	},
	{
		name: 'riichi',
		fan: 1,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			return !state.doubleRiichi && (state.riichi ?? false);
		},
	},
	{
		name: 'double-riichi',
		fan: 2,
		isYakuman: false,
		calc: (state: EnvForCalcYaku) => {
			return state.doubleRiichi ?? false;
		},
	},
	{
		name: 'ippatsu',
		fan: 1,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			return state.ippatsu ?? false;
		},
	},
	{
		name: 'rinshan',
		fan: 1,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			return (state.tsumoTile != null && state.rinshan) ?? false;
		},
	},
	{
		name: 'haitei',
		fan: 1,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			return (state.tsumoTile != null && state.haitei) ?? false;
		},
	},
	{
		name: 'hotei',
		fan: 1,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			return (state.ronTile != null && state.hotei) ?? false;
		},
	},
	new Yakuhai('red', 'chun'),
	new Yakuhai('white', 'haku'),
	new Yakuhai('green', 'hatsu'),
	new FieldWind('field-wind-e', 'e'),
	new FieldWind('field-wind-s', 's'),
	new FieldWind('field-wind-w', 'w'),
	new FieldWind('field-wind-n', 'n'),
	new SeatWind('seat-wind-e', 'e'),
	new SeatWind('seat-wind-s', 's'),
	new SeatWind('seat-wind-w', 'w'),
	new SeatWind('seat-wind-n', 'n'),
	{
		name: 'tanyao',
		fan: 1,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			return (
				(!state.handTiles.some(t => includes(YAOCHU_TILES, t))) &&
			(state.huros.filter(huro =>
				huro.type === 'pon' ? includes(YAOCHU_TILES, huro.tile) :
				huro.type === 'ankan' ? includes(YAOCHU_TILES, huro.tile) :
				huro.type === 'minkan' ? includes(YAOCHU_TILES, huro.tile) :
				huro.type === 'cii' ? huro.tiles.some(t2 => includes(YAOCHU_TILES, t2)) :
				false).length === 0)
			);
		},
	},
	{
		name: 'pinfu',
		fan: 1,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantouWithWait | null) => {
			if (fourMentsuOneJyantou == null) return false;

			// 面前じゃないとダメ
			if (state.huros.some(huro => includes(CALL_HURO_TYPES, huro.type))) return false;
			// 三元牌はダメ
			if (state.handTiles.some(t => ['haku', 'hatsu', 'chun'].includes(t))) return false;

			// 両面待ちかどうか
			if (!(fourMentsuOneJyantou != null && fourMentsuOneJyantou.waitedFor === 'mentsu' && isRyanmen(fourMentsuOneJyantou.waitedTaatsu))) return false;

			// 風牌判定(役牌でなければOK)
			if (fourMentsuOneJyantou.head === state.seatWind) return false;
			if (fourMentsuOneJyantou.head === state.fieldWind) return false;

			// 全て順子か？
			if (fourMentsuOneJyantou.mentsus.some((mentsu) => mentsu[0] === mentsu[1])) return false;

			return true;
		},
	},
	{
		name: 'honitsu',
		fan: 3,
		isYakuman: false,
		kuisagari: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			const tiles = state.handTiles;
			let manzuCount = tiles.filter(t => includes(MANZU_TILES, t)).length;
			let pinzuCount = tiles.filter(t => includes(PINZU_TILES, t)).length;
			let souzuCount = tiles.filter(t => includes(SOUZU_TILES, t)).length;
			let charCount = tiles.filter(t => includes(CHAR_TILES, t)).length;

			for (const huro of state.huros) {
				const huroTiles = huro.type === 'cii' ? huro.tiles : huro.type === 'pon' ? [huro.tile, huro.tile, huro.tile] : [huro.tile, huro.tile, huro.tile, huro.tile];
				manzuCount += huroTiles.filter(t => includes(MANZU_TILES, t)).length;
				pinzuCount += huroTiles.filter(t => includes(PINZU_TILES, t)).length;
				souzuCount += huroTiles.filter(t => includes(SOUZU_TILES, t)).length;
				charCount += huroTiles.filter(t => includes(CHAR_TILES, t)).length;
			}

			if (manzuCount > 0 && pinzuCount > 0) return false;
			if (manzuCount > 0 && souzuCount > 0) return false;
			if (pinzuCount > 0 && souzuCount > 0) return false;
			if (charCount === 0) return false;

			return true;
		},
	},
	{
		name: 'chinitsu',
		fan: 6,
		isYakuman: false,
		kuisagari: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			const tiles = state.handTiles;
			let manzuCount = tiles.filter(t => includes(MANZU_TILES, t)).length;
			let pinzuCount = tiles.filter(t => includes(PINZU_TILES, t)).length;
			let souzuCount = tiles.filter(t => includes(SOUZU_TILES, t)).length;
			let charCount = tiles.filter(t => includes(CHAR_TILES, t)).length;

			for (const huro of state.huros) {
				const huroTiles = huro.type === 'cii' ? huro.tiles : huro.type === 'pon' ? [huro.tile, huro.tile, huro.tile] : [huro.tile, huro.tile, huro.tile, huro.tile];
				manzuCount += huroTiles.filter(t => includes(MANZU_TILES, t)).length;
				pinzuCount += huroTiles.filter(t => includes(PINZU_TILES, t)).length;
				souzuCount += huroTiles.filter(t => includes(SOUZU_TILES, t)).length;
				charCount += huroTiles.filter(t => includes(CHAR_TILES, t)).length;
			}

			if (charCount > 0) return false;
			if (manzuCount > 0 && pinzuCount > 0) return false;
			if (manzuCount > 0 && souzuCount > 0) return false;
			if (pinzuCount > 0 && souzuCount > 0) return false;

			return true;
		},
	},
	{
		name: 'iipeko',
		fan: 1,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			// 面前じゃないとダメ
			if (state.huros.some(huro => includes(CALL_HURO_TYPES, huro.type))) return false;

			// 同じ順子が2つあるか？
			return countIndenticalMentsuPairs(fourMentsuOneJyantou.mentsus) === 1;
		},
	},
	{
		name: 'ryampeko',
		fan: 3,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			// 面前じゃないとダメ
			if (state.huros.some(huro => includes(CALL_HURO_TYPES, huro.type))) return false;

			// 2つの同じ順子が2組あるか？
			return countIndenticalMentsuPairs(fourMentsuOneJyantou.mentsus) === 2;
		},
	},
	{
		name: 'toitoi',
		fan: 2,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			if (state.huros.length > 0) {
				if (state.huros.some(huro => huro.type === 'cii')) return false;
			}

			// 全て刻子か？
			if (!fourMentsuOneJyantou.mentsus.every((mentsu) => mentsu[0] === mentsu[1])) return false;

			return true;
		},
	},
	{
		name: 'sananko',
		fan: 2,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantouWithWait | null) => {
			return fourMentsuOneJyantou != null && countAnkos(state, fourMentsuOneJyantou) === 3;
		},
	},
	{
		name: 'honroto',
		fan: 2,
		isYakuman: false,
		calc: (state: EnvForCalcYaku) => {
			return state.huros.every(huro => huro.type !== 'cii' && includes(YAOCHU_TILES, huro.tile)) &&
			state.handTiles.every(tile => includes(YAOCHU_TILES, tile));
		},
	},
	{
		name: 'sankantsu',
		fan: 2,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			return fourMentsuOneJyantou != null &&
			state.huros.filter(huro => huro.type === 'ankan' || huro.type === 'minkan').length === 3;
		},
	},
	{
		name: 'sanshoku-dojun',
		fan: 2,
		isYakuman: false,
		kuisagari: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			const shuntsus = fourMentsuOneJyantou.mentsus.filter(tiles => isShuntu(tiles));

			for (const shuntsu of shuntsus) {
				if (isManzu(shuntsu[0])) {
					if (shuntsus.some(tiles => isPinzu(tiles[0]) && isSameNumberTile(tiles[0], shuntsu[0]) && isSameNumberTile(tiles[1], shuntsu[1]) && isSameNumberTile(tiles[2], shuntsu[2]))) {
						if (shuntsus.some(tiles => isSouzu(tiles[0]) && isSameNumberTile(tiles[0], shuntsu[0]) && isSameNumberTile(tiles[1], shuntsu[1]) && isSameNumberTile(tiles[2], shuntsu[2]))) {
							return true;
						}
					}
				} else if (isPinzu(shuntsu[0])) {
					if (shuntsus.some(tiles => isManzu(tiles[0]) && isSameNumberTile(tiles[0], shuntsu[0]) && isSameNumberTile(tiles[1], shuntsu[1]) && isSameNumberTile(tiles[2], shuntsu[2]))) {
						if (shuntsus.some(tiles => isSouzu(tiles[0]) && isSameNumberTile(tiles[0], shuntsu[0]) && isSameNumberTile(tiles[1], shuntsu[1]) && isSameNumberTile(tiles[2], shuntsu[2]))) {
							return true;
						}
					}
				} else if (isSouzu(shuntsu[0])) {
					if (shuntsus.some(tiles => isManzu(tiles[0]) && isSameNumberTile(tiles[0], shuntsu[0]) && isSameNumberTile(tiles[1], shuntsu[1]) && isSameNumberTile(tiles[2], shuntsu[2]))) {
						if (shuntsus.some(tiles => isPinzu(tiles[0]) && isSameNumberTile(tiles[0], shuntsu[0]) && isSameNumberTile(tiles[1], shuntsu[1]) && isSameNumberTile(tiles[2], shuntsu[2]))) {
							return true;
						}
					}
				}
			}

			return false;
		},
	},
	{
		name: 'sanshoku-doko',
		fan: 2,
		isYakuman: false,
		kuisagari: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			const kotsus = fourMentsuOneJyantou.mentsus.filter(tiles => isKotsu(tiles));

			for (const kotsu of kotsus) {
				if (isManzu(kotsu[0])) {
					if (kotsus.some(tiles => isPinzu(tiles[0]) && isSameNumberTile(tiles[0], kotsu[0]))) {
						if (kotsus.some(tiles => isSouzu(tiles[0]) && isSameNumberTile(tiles[0], kotsu[0]))) {
							return true;
						}
					}
				} else if (isPinzu(kotsu[0])) {
					if (kotsus.some(tiles => isManzu(tiles[0]) && isSameNumberTile(tiles[0], kotsu[0]))) {
						if (kotsus.some(tiles => isSouzu(tiles[0]) && isSameNumberTile(tiles[0], kotsu[0]))) {
							return true;
						}
					}
				} else if (isSouzu(kotsu[0])) {
					if (kotsus.some(tiles => isManzu(tiles[0]) && isSameNumberTile(tiles[0], kotsu[0]))) {
						if (kotsus.some(tiles => isPinzu(tiles[0]) && isSameNumberTile(tiles[0], kotsu[0]))) {
							return true;
						}
					}
				}
			}

			return false;
		},
	},
	{
		name: 'ittsu',
		fan: 2,
		isYakuman: false,
		kuisagari: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			const shuntsus = fourMentsuOneJyantou.mentsus.filter(tiles => isShuntu(tiles));
			shuntsus.push(...state.huros.filter((huro): huro is Cii => huro.type === 'cii').map(huro => huro.tiles));

			if (shuntsus.some(tiles => tiles[0] === 'm1' && tiles[1] === 'm2' && tiles[2] === 'm3')) {
				if (shuntsus.some(tiles => tiles[0] === 'm4' && tiles[1] === 'm5' && tiles[2] === 'm6')) {
					if (shuntsus.some(tiles => tiles[0] === 'm7' && tiles[1] === 'm8' && tiles[2] === 'm9')) {
						return true;
					}
				}
			}
			if (shuntsus.some(tiles => tiles[0] === 'p1' && tiles[1] === 'p2' && tiles[2] === 'p3')) {
				if (shuntsus.some(tiles => tiles[0] === 'p4' && tiles[1] === 'p5' && tiles[2] === 'p6')) {
					if (shuntsus.some(tiles => tiles[0] === 'p7' && tiles[1] === 'p8' && tiles[2] === 'p9')) {
						return true;
					}
				}
			}
			if (shuntsus.some(tiles => tiles[0] === 's1' && tiles[1] === 's2' && tiles[2] === 's3')) {
				if (shuntsus.some(tiles => tiles[0] === 's4' && tiles[1] === 's5' && tiles[2] === 's6')) {
					if (shuntsus.some(tiles => tiles[0] === 's7' && tiles[1] === 's8' && tiles[2] === 's9')) {
						return true;
					}
				}
			}

			return false;
		},
	},
	{
		name: 'chanta',
		fan: 2,
		isYakuman: false,
		kuisagari: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			const { head, mentsus } = fourMentsuOneJyantou;
			const { huros } = state;

			// 雀頭は幺九牌じゃないとダメ
			if (!includes(YAOCHU_TILES, head)) return false;

			// 順子は1つ以上じゃないとダメ
			if (!mentsus.some(mentsu => isShuntu(mentsu))) return false;

			// いずれかの雀頭か面子に字牌を含まないとダメ
			if (!(includes(CHAR_TILES, head) ||
			mentsus.some(mentsu => includes(CHAR_TILES, mentsu[0])) ||
			huros.some(huro => huro.type !== 'cii' && includes(CHAR_TILES, huro.tile)))) return false;

			// 全ての面子に幺九牌が含まれる
			return (mentsus.every(mentsu => mentsu.some(tile => includes(YAOCHU_TILES, tile))) &&
			huros.every(huro => huro.type === 'cii' ?
				huro.tiles.some(tile => includes(YAOCHU_TILES, tile)) :
				includes(YAOCHU_TILES, huro.tile)));
		},
	},
	{
		name: 'junchan',
		fan: 3,
		isYakuman: false,
		kuisagari: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			const { head, mentsus } = fourMentsuOneJyantou;
			const { huros } = state;

			// 雀頭は老頭牌じゃないとダメ
			if (!includes(TERMINAL_TILES, head)) return false;

			// 順子は1つ以上じゃないとダメ
			if (!mentsus.some(mentsu => isShuntu(mentsu))) return false;

			// 全ての面子に老頭牌が含まれる
			return (mentsus.every(mentsu => mentsu.some(tile => includes(TERMINAL_TILES, tile))) &&
			huros.every(huro => huro.type === 'cii' ?
				huro.tiles.some(tile => includes(TERMINAL_TILES, tile)) :
				includes(TERMINAL_TILES, huro.tile)));
		},
	},
	{
		name: 'chitoitsu',
		fan: 2,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou != null) return false;
			if (state.huros.length > 0) return false;
			const countMap = new Map<TileType, number>();
			for (const tile of state.handTiles) {
				const count = (countMap.get(tile) ?? 0) + 1;
				countMap.set(tile, count);
			}
			return Array.from(countMap.values()).every(c => c === 2);
		},
	},
	{
		name: 'shosangen',
		fan: 2,
		isYakuman: false,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			const kotsuTiles = fourMentsuOneJyantou.mentsus.filter(tiles => isKotsu(tiles)).map(tiles => tiles[0]);

			for (const huro of state.huros) {
				if (huro.type === 'cii') {
				// nop
				} else if (huro.type === 'pon') {
					kotsuTiles.push(huro.tile);
				} else {
					kotsuTiles.push(huro.tile);
				}
			}

			switch (fourMentsuOneJyantou.head) {
				case 'haku': return kotsuTiles.includes('hatsu') && kotsuTiles.includes('chun');
				case 'hatsu': return kotsuTiles.includes('haku') && kotsuTiles.includes('chun');
				case 'chun': return kotsuTiles.includes('haku') && kotsuTiles.includes('hatsu');
			}

			return false;
		},
	},
];

export const YAKUMAN_DEFINITIONS: YakumanDefinition[] = [
	{
		name: 'suanko-tanki',
		isYakuman: true,
		isDoubleYakuman: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantouWithWait | null) => {
			return fourMentsuOneJyantou != null && fourMentsuOneJyantou.waitedFor === 'head' && countAnkos(state, fourMentsuOneJyantou) === 4;
		},
	},
	{
		name: 'suanko',
		isYakuman: true,
		upper: 'suanko-tanki',
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantouWithWait | null) => {
			return fourMentsuOneJyantou != null && countAnkos(state, fourMentsuOneJyantou) === 4;
		},
	},
	{
		name: 'daisangen',
		isYakuman: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			const kotsuTiles = fourMentsuOneJyantou.mentsus.filter(tiles => isKotsu(tiles)).map(tiles => tiles[0]);

			for (const huro of state.huros) {
				if (huro.type === 'cii') {
				// nop
				} else if (huro.type === 'pon') {
					kotsuTiles.push(huro.tile);
				} else {
					kotsuTiles.push(huro.tile);
				}
			}

			return kotsuTiles.includes('haku') && kotsuTiles.includes('hatsu') && kotsuTiles.includes('chun');
		},
	},
	{
		name: 'shosushi',
		isYakuman: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			let all = [...state.handTiles];
			for (const huro of state.huros) {
				if (huro.type === 'cii') {
					all = [...all, ...huro.tiles];
				} else if (huro.type === 'pon') {
					all = [...all, huro.tile, huro.tile, huro.tile];
				} else {
					all = [...all, huro.tile, huro.tile, huro.tile, huro.tile];
				}
			}

			switch (fourMentsuOneJyantou.head) {
				case 'e': return (countTiles(all, 's') === 3) && (countTiles(all, 'w') === 3) && (countTiles(all, 'n') === 3);
				case 's': return (countTiles(all, 'e') === 3) && (countTiles(all, 'w') === 3) && (countTiles(all, 'n') === 3);
				case 'w': return (countTiles(all, 'e') === 3) && (countTiles(all, 's') === 3) && (countTiles(all, 'n') === 3);
				case 'n': return (countTiles(all, 'e') === 3) && (countTiles(all, 's') === 3) && (countTiles(all, 'w') === 3);
			}

			return false;
		},
	},
	{
		name: 'daisushi',
		isYakuman: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			const kotsuTiles = fourMentsuOneJyantou.mentsus.filter(tiles => isKotsu(tiles)).map(tiles => tiles[0]);

			for (const huro of state.huros) {
				if (huro.type === 'cii') {
				// nop
				} else if (huro.type === 'pon') {
					kotsuTiles.push(huro.tile);
				} else {
					kotsuTiles.push(huro.tile);
				}
			}

			return kotsuTiles.includes('e') && kotsuTiles.includes('s') && kotsuTiles.includes('w') && kotsuTiles.includes('n');
		},
	},
	{
		name: 'tsuiso',
		isYakuman: true,
		calc: (state: EnvForCalcYaku) => {
			const tiles = state.handTiles;
			let manzuCount = tiles.filter(t => includes(MANZU_TILES, t)).length;
			let pinzuCount = tiles.filter(t => includes(PINZU_TILES, t)).length;
			let souzuCount = tiles.filter(t => includes(SOUZU_TILES, t)).length;

			for (const huro of state.huros) {
				const huroTiles = huro.type === 'cii' ? huro.tiles : huro.type === 'pon' ? [huro.tile, huro.tile, huro.tile] : [huro.tile, huro.tile, huro.tile, huro.tile];
				manzuCount += huroTiles.filter(t => includes(MANZU_TILES, t)).length;
				pinzuCount += huroTiles.filter(t => includes(PINZU_TILES, t)).length;
				souzuCount += huroTiles.filter(t => includes(SOUZU_TILES, t)).length;
			}

			if (manzuCount > 0 || pinzuCount > 0 || souzuCount > 0) return false;

			return true;
		},
	},
	{
		name: 'ryuiso',
		isYakuman: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			if (state.handTiles.some(t => !RYUISO_TILES.includes(t))) return false;

			for (const huro of state.huros) {
				const huroTiles = huro.type === 'cii' ? huro.tiles : huro.type === 'pon' ? [huro.tile, huro.tile, huro.tile] : [huro.tile, huro.tile, huro.tile, huro.tile];
				if (huroTiles.some(t => !RYUISO_TILES.includes(t))) return false;
			}

			return true;
		},
	},
	{
		name: 'chinroto',
		isYakuman: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			return fourMentsuOneJyantou != null &&
			state.huros.every(huro => huro.type !== 'cii' && includes(TERMINAL_TILES, huro.tile)) &&
			state.handTiles.every(tile => includes(TERMINAL_TILES, tile));
		},
	},
	{
		name: 'sukantsu',
		isYakuman: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			return fourMentsuOneJyantou != null &&
			state.huros.filter(huro => huro.type === 'ankan' || huro.type === 'minkan').length === 4;
		},
	},
	{
		name: 'churen-9',
		isYakuman: true,
		isDoubleYakuman: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			// 面前じゃないとダメ
			if (state.huros.some(huro => includes(CALL_HURO_TYPES, huro.type))) return false;

			const agariTile = state.tsumoTile ?? state.ronTile;
			if (agariTile == null) {
				return false;
			}
			const tempaiTiles = [...state.handTiles];
			tempaiTiles.splice(state.handTiles.indexOf(agariTile), 1);

			if (isManzu(agariTile)) {
				if ((countTiles(tempaiTiles, 'm1') === 3) && (countTiles(tempaiTiles, 'm9') === 3)) {
					if (tempaiTiles.includes('m2') && tempaiTiles.includes('m3') && tempaiTiles.includes('m4') && tempaiTiles.includes('m5') && tempaiTiles.includes('m6') && tempaiTiles.includes('m7') && tempaiTiles.includes('m8')) {
						return true;
					}
				}
			} else if (isPinzu(agariTile)) {
				if ((countTiles(tempaiTiles, 'p1') === 3) && (countTiles(tempaiTiles, 'p9') === 3)) {
					if (tempaiTiles.includes('p2') && tempaiTiles.includes('p3') && tempaiTiles.includes('p4') && tempaiTiles.includes('p5') && tempaiTiles.includes('p6') && tempaiTiles.includes('p7') && tempaiTiles.includes('p8')) {
						return true;
					}
				}
			} else if (isSouzu(agariTile)) {
				if ((countTiles(tempaiTiles, 's1') === 3) && (countTiles(tempaiTiles, 's9') === 3)) {
					if (tempaiTiles.includes('s2') && tempaiTiles.includes('s3') && tempaiTiles.includes('s4') && tempaiTiles.includes('s5') && tempaiTiles.includes('s6') && tempaiTiles.includes('s7') && tempaiTiles.includes('s8')) {
						return true;
					}
				}
			}

			return false;
		},
	},
	{
		name: 'churen',
		upper: 'churen-9',
		isYakuman: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			if (fourMentsuOneJyantou == null) return false;

			// 面前じゃないとダメ
			if (state.huros.some(huro => includes(CALL_HURO_TYPES, huro.type))) return false;

			if (isManzu(state.handTiles[0])) {
				if ((countTiles(state.handTiles, 'm1') === 3) && (countTiles(state.handTiles, 'm9') === 3)) {
					if (state.handTiles.includes('m2') && state.handTiles.includes('m3') && state.handTiles.includes('m4') && state.handTiles.includes('m5') && state.handTiles.includes('m6') && state.handTiles.includes('m7') && state.handTiles.includes('m8')) {
						return true;
					}
				}
			} else if (isPinzu(state.handTiles[0])) {
				if ((countTiles(state.handTiles, 'p1') === 3) && (countTiles(state.handTiles, 'p9') === 3)) {
					if (state.handTiles.includes('p2') && state.handTiles.includes('p3') && state.handTiles.includes('p4') && state.handTiles.includes('p5') && state.handTiles.includes('p6') && state.handTiles.includes('p7') && state.handTiles.includes('p8')) {
						return true;
					}
				}
			} else if (isSouzu(state.handTiles[0])) {
				if ((countTiles(state.handTiles, 's1') === 3) && (countTiles(state.handTiles, 's9') === 3)) {
					if (state.handTiles.includes('s2') && state.handTiles.includes('s3') && state.handTiles.includes('s4') && state.handTiles.includes('s5') && state.handTiles.includes('s6') && state.handTiles.includes('s7') && state.handTiles.includes('s8')) {
						return true;
					}
				}
			}

			return false;
		},
	},
	{
		name: 'kokushi-13',
		isYakuman: true,
		isDoubleYakuman: true,
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			const agariTile = state.tsumoTile ?? state.ronTile;
			return KOKUSHI_TILES.every(t => state.handTiles.includes(t)) && countTiles(state.handTiles, agariTile) === 2;
		},
	},
	{
		name: 'kokushi',
		isYakuman: true,
		upper: 'kokushi-13',
		calc: (state: EnvForCalcYaku, fourMentsuOneJyantou: FourMentsuOneJyantou | null) => {
			return KOKUSHI_TILES.every(t => state.handTiles.includes(t)) && KOKUSHI_TILES.some(t => countTiles(state.handTiles, t) === 2);
		},
	},
	{
		name: 'tenho',
		isYakuman: true,
		calc: (state: EnvForCalcYaku) => {
			return (state.firstTurn ?? false) && state.tsumoTile != null && state.seatWind === 'e';
		},
	},
	{
		name: 'chiho',
		isYakuman: true,
		calc: (state: EnvForCalcYaku) => {
			return (state.firstTurn ?? false) && state.tsumoTile != null && state.seatWind !== 'e';
		},
	},
];

export function convertHuroForCalcYaku(huro: Huro): HuroForCalcYaku {
	switch (huro.type) {
		case 'pon':
		case 'ankan':
		case 'minkan':
			return {
				type: huro.type,
				tile: TILE_ID_MAP.get(huro.tiles[0])!.t,
			};
		case 'cii':
			return {
				type: 'cii',
				tiles: huro.tiles.map(tile => TILE_ID_MAP.get(tile)!.t) as [TileType, TileType, TileType],
			};
	}
}

const NORMAL_YAKU_DATA_MAP = new Map<NormalYakuName, Required<NormalYakuData>>(
	NORMAL_YAKU_DEFINITIONS.map(yaku => [yaku.name, {
		name: yaku.name,
		upper: yaku.upper ?? null,
		fan: yaku.fan,
		isYakuman: false,
		kuisagari: yaku.kuisagari ?? false,
	}] as const),
);

const YAKUMAN_DATA_MAP = new Map<YakuName, Required<YakumanData>>(
	YAKUMAN_DEFINITIONS.map(yaku => [yaku.name, {
		name: yaku.name,
		upper: yaku.upper ?? null,
		fan: null,
		isYakuman: true,
		isDoubleYakuman: yaku.isDoubleYakuman ?? false,
	}]),
);

export function calcYakusWithDetail(state: EnvForCalcYaku): YakuSet {
	if (state.riichi && state.huros.some(huro => includes(CALL_HURO_TYPES, huro.type)) ) {
		throw new TypeError('Invalid riichi state with call huros');
	}

	const agariTile = state.tsumoTile ?? state.ronTile;
	if (!state.handTiles.includes(agariTile)) {
		throw new TypeError('Agari tile not included in hand tiles');
	}

	if (state.handTiles.length + state.huros.length * 3 !== 14) {
		throw new TypeError('Invalid tile count');
	}

	const oneHeadFourMentsuPatterns: (FourMentsuOneJyantou | null)[] = analyzeFourMentsuOneJyantou(state.handTiles);
	if (oneHeadFourMentsuPatterns.length === 0) oneHeadFourMentsuPatterns.push(null);

	const waitPatterns = oneHeadFourMentsuPatterns.map(
		fourMentsuOneJyantou => calcWaitPatterns(fourMentsuOneJyantou, agariTile),
	).flat();

	const yakumanPatterns = waitPatterns.map(fourMentsuOneJyantouWithWait => {
		const matchedYakus: Required<YakumanData>[] = [];
		for (const yakuDef of YAKUMAN_DEFINITIONS) {
			if (yakuDef.upper && matchedYakus.some(yaku => yaku.name === yakuDef.upper)) continue;
			const matched = yakuDef.calc(state, fourMentsuOneJyantouWithWait);
			if (matched) {
				matchedYakus.push(YAKUMAN_DATA_MAP.get(yakuDef.name)!);
			}
		}
		return matchedYakus;
	}).filter(yakus => yakus.length > 0);

	if (yakumanPatterns.length > 0) {
		return new YakumanSet(yakumanPatterns[0]);
	}

	const yakuPatterns = waitPatterns.map(
		fourMentsuOneJyantouWithWait => NORMAL_YAKU_DEFINITIONS.filter(
			yakuDef => yakuDef.calc(state, fourMentsuOneJyantouWithWait),
		).map(yakuDef => NORMAL_YAKU_DATA_MAP.get(yakuDef.name)!),
	).filter(yakus => yakus.length > 0);

	const isMenzen = state.huros.some(huro => includes(CALL_HURO_TYPES, huro.type));

	if (yakuPatterns.length === 0) {
		return new NormalYakuSet(isMenzen, []);
	}

	let maxYakus = yakuPatterns[0];
	let maxFan = 0;
	for (const yakus of yakuPatterns) {
		let fan = 0;
		for (const yaku of yakus) {
			if (yaku.kuisagari && !isMenzen) {
				fan += yaku.fan! - 1;
			} else {
				fan += yaku.fan!;
			}
		}
		if (fan > maxFan) {
			maxFan = fan;
			maxYakus = yakus;
		}
	}

	return new NormalYakuSet(isMenzen, maxYakus);
}

export function calcYakus(state: EnvForCalcYaku): YakuName[] {
	return calcYakusWithDetail(state).yakuNames;
}