var ItemControl = {
	decreaseItem: function(unit, item) {
		this.decreaseLimit(unit, item);
		
		if (this.isItemBroken(item)) {
			this.lostItem(unit, item);
		}
	},
	
	decreaseLimit: function(unit, item) {
		var limit;
		
		// 耐久が0のアイテムは減らない
		if (item.getLimitMax() === 0) {
			return;
		}
		
		if (item.isWeapon()) {
			// 武器が破損している場合は減らない
			if (item.getLimit() === WeaponLimitValue.BROKEN) {
				return;
			}
		}
		
		limit = item.getLimit() - 1;
		item.setLimit(limit);
	},
	
	lostItem: function(unit, item) {
		var weaponType = item.getWeaponType();
		
		if (weaponType.getBreakedWeapon() !== null) {
			// 「破損時の武器」が設定されている場合は、破損状態を示す値を設定する
			item.setLimit(WeaponLimitValue.BROKEN);
			return;
		}
		
		if (unit === null) {
			StockItemControl.cutStockItem(StockItemControl.getIndexFromItem(item));
		}
		else {
			this.deleteItem(unit, item);
		}
	},
	
	deleteItem: function(unit, item) {
		var i;
		var count = UnitItemControl.getPossessionItemCount(unit);
		
		for (i = 0; i < count; i++) {
			if (UnitItemControl.getItem(unit, i) === item) {
				// unitのアイテム欄から外す
				UnitItemControl.cutItem(unit, i);
				return true;
			}
		}
		
		return false;
	},
	
	deleteTrophy: function(unit, item) {
		var i, trophy;
		var list = unit.getDropTrophyList();
		var count = list.getCount();
		
		for (i = 0; i < count; i++) {
			trophy = list.getData(i);
			if (ItemControl.compareItem(trophy.getItem(), item)) {
				// itemと同じidのアイテムがドロップトロフィーに含まれるため削除
				root.getCurrentSession().getTrophyEditor().deleteTrophy(list, trophy);
				return true;
			}
		}
		
		return false;
	},
	
	isItemBroken: function(item) {
		// 耐久が無限でないアイテムの耐久が0であるか調べる
		return item.getLimitMax() !== 0 && item.getLimit() === 0;
	},
	
	// 後のバージョンで削除
	isWeaponBroken: function(weapon) {
		return this.isItemBroken(weapon);
	},
	
	// 後のバージョンで削除
	isWeaponLimitless: function(unit, weapon) {
		return false;
	},
	
	isWeaponTypeAllowed: function(refList, weapon) {
		var i;
		var count = refList.getTypeCount();
		
		for (i = 0; i < count; i++) {
			if (weapon.isWeaponTypeMatched(refList.getTypeData(i))) {
				break;
			}
		}
		
		if (i === count) {
			return false;
		}
		
		return true;
	},
	
	getEquippedWeapon: function(unit) {
		var i, item, count;
		
		if (unit === null) {
			return null;
		}
		
		count = UnitItemControl.getPossessionItemCount(unit);
		
		// 装備している武器とは、アイテム欄の中で先頭の武器
		for (i = 0; i < count; i++) {
			item = UnitItemControl.getItem(unit, i);
			if (item !== null && this.isWeaponAvailable(unit, item)) {
				return item;
			}
		}
		
		return null;
	},
	
	setEquippedWeapon: function(unit, targetItem) {
		var i, item;
		var count = UnitItemControl.getPossessionItemCount(unit);
		var fastIndex = -1, targetIndex = -1;
		
		// unitがtargetItemの武器を装備する。
		// targetItemはアイテム欄の先頭に配置される。
		
		for (i = 0; i < count; i++) {
			item = UnitItemControl.getItem(unit, i);
			if (item !== null && fastIndex === -1) {
				// アイテム欄の中で先頭のアイテムのインデックスを保存
				fastIndex = i;
			}
			
			if (item === targetItem) {
				// 装備するアイテムのインデックスを保存
				targetIndex = i;
			}
		}
		
		if (fastIndex === -1 || targetIndex === -1) {
			return;
		}
		
		// 交換先が一致する場合は交換しない
		if (fastIndex === targetIndex) {
			return;
		}
		
		// アイテムを入れ替える
		item = UnitItemControl.getItem(unit, fastIndex);
		UnitItemControl.setItem(unit, fastIndex, targetItem);
		UnitItemControl.setItem(unit, targetIndex, item);
		
		this.updatePossessionItem(unit);
	},
	
	// このメソッドは、アイテム欄に変化が生じた場合に呼ばれる。
	// たとえば、アイテム装備、増加、交換、ストック交換、武器耐久ゼロなど。
	updatePossessionItem: function(unit) {
		var scene = root.getCurrentScene();
		
		// シーンがFREEでもEVENTでもない場合は、常にHPは最大HPと一致する。
		// この処理を忘れた場合は、アイテム交換やアイテム増減でHPが変化する。
		if (scene !== SceneType.FREE && scene !== SceneType.EVENT) {
			unit.setHp(ParamBonus.getMhp(unit));
		}
		
		// HPは最大HPを超えてはならない
		if (unit.getHp() > ParamBonus.getMhp(unit)) {
			unit.setHp(ParamBonus.getMhp(unit));
		}
		else if (unit.getHp() < 1) {
			unit.setHp(1);
		}
	},
	
	// unitがitemを装備できるか調べる。
	// unitがitemを装備しているか調べるのではない。
	isWeaponAvailable: function(unit, item) {
		if (item === null) {
			return false;
		}
		
		// itemが武器でない場合は装備できない
		if (!item.isWeapon()) {
			return false;
		}
		
		// 「熟練度」を調べる
		if (!this._isWeaponLevel(unit, item)) {
			return false;
		}
		
		// 「戦士系」などが一致するか調べる
		if (!this._compareTemplateAndCategory(unit, item)) {
			return false;
		}
		
		// クラスの「装備可能武器」のリストに入っているか調べる
		if (!this.isWeaponTypeAllowed(unit.getClass().getEquipmentWeaponTypeReferenceList(), item)) {
			return false;
		}
		
		// 「専用データ」を調べる
		if (!this.isOnlyData(unit, item)) {
			return false;
		}
		
		if (item.getWeaponCategoryType() === WeaponCategoryType.MAGIC) {
			// 「魔法攻撃」が禁止されているか調べる
			if (StateControl.isBadStateFlag(unit, BadStateFlag.MAGIC)) {
				return false;
			}
		}
		else {
			// 「物理攻撃」が禁止されているか調べる
			if (StateControl.isBadStateFlag(unit, BadStateFlag.PHYSICS)) {
				return false;
			}
		}
		
		return true;
	},
	
	// unitがアイテムを使用できるか調べる
	isItemUsable: function(unit, item) {
		// 武器は使用できない
		if (item.isWeapon()) {
			return false;
		}
		
		// アイテムの使用が禁止されているか調べる
		if (StateControl.isBadStateFlag(unit, BadStateFlag.ITEM)) {
			return false;
		}
			
		if (item.isWand()) {
			// アイテムが杖の場合は、クラスが杖を使用できなければならない
			if (!(unit.getClass().getClassOption() & ClassOptionFlag.WAND)) {
				return false;
			}
			
			// 杖の使用が禁止されているか調べる
			if (StateControl.isBadStateFlag(unit, BadStateFlag.WAND)) {
				return false;
			}
		}
		
		if (item.getItemType() === ItemType.KEY) {
			if (item.getKeyInfo().isAdvancedKey()) {
				// 「高度な鍵」の場合は、クラスが鍵を使用できなければならない
				if (!(unit.getClass().getClassOption() & ClassOptionFlag.KEY)) {
					return false;
				}
			}
		}
		
		// 「専用データ」を調べる
		if (!this.isOnlyData(unit, item)) {
			return false;
		}
		
		return true;
	},
	
	// 「専用データ」を調べる
	isOnlyData: function(unit, item) {
		// 「専用データ」にスキルが指定されている場合は、武器のスキルも調べる必要があるが、
		// その武器を第2引数に指定することでループするのを防ぐ。
		return item.getAvailableAggregation().isConditionFromWeapon(unit, item);
	},
	
	// 特効かどうかを調べる
	isEffectiveData: function(unit, item) {
		var aggregation = item.getEffectiveAggregation();
		
		if (aggregation.getObjectCount() === 0) {
			return false;
		}
		
		return aggregation.isCondition(unit);
	},
	
	// unitが所持しているアイテムから、flagを含む鍵アイテムを取得する
	getKeyItem: function(unit, flag) {
		var i, item, info, isKey;
		var count = UnitItemControl.getPossessionItemCount(unit);
		
		// アイテムを順番に調べる。
		// 前方のアイテムほど優先される。
		for (i = 0; i < count; i++) {
			item = UnitItemControl.getItem(unit, i);
			if (item === null) {
				continue;
			}
			
			if (!item.isWeapon() && item.getItemType() === ItemType.KEY && this.isItemUsable(unit, item)) {
				isKey = false;
				info = item.getKeyInfo();
				
				// 杖の場合はアイテムを返さない
				if (!item.isWand()) {
					if (info.getKeyFlag() & flag) {
						isKey = true;
					}
					else {
						isKey = false;
					}
				}
				
				if (isKey) {
					return item;
				}
			}
		}
		
		return null;
	},
	
	// itemとtargetItemが同一種類かどうか調べる
	compareItem: function(item, targetItem) {
		var id, targetId;
		
		if (item === null || targetItem === null) {
			return false;
		}
		
		id = item.getId();
		targetId = targetItem.getId();
		
		if (!item.isWeapon()) {
			id += ItemIdValue.BASE;
		}
		
		if (!targetItem.isWeapon()) {
			targetId += ItemIdValue.BASE;
		}
		
		// 通常、データのidはそれぞれ唯一の値である。
		// ただし、同じアイテムは同じIDを持つため、以下の判定は有効である。
		return id === targetId;
	},
	
	_isWeaponLevel: function(unit, item) {
		// ParamBonus.getWlvを呼び出すとループする
		return ParamBonus.getBonusFromWeapon(unit, ParamType.WLV, item) >= item.getWeaponLevel();
	},
	
	_compareTemplateAndCategory: function(unit, item) {
		var result = false;
		var classMotionFlag = unit.getClass().getClassMotionFlag();
		var weaponCategoryType = item.getWeaponCategoryType();
		
		// クラスの「戦士系」、「弓兵系」、「魔道士系」の全てが空白である場合は、
		// 全ての武器を装備できる。
		if (classMotionFlag === 0) {
			return true;
		}
		
		if (weaponCategoryType === WeaponCategoryType.PHYSICS) {
			if (classMotionFlag & ClassMotionFlag.FIGHTER) {
				result = true;
			}
		}
		else if (weaponCategoryType === WeaponCategoryType.SHOOT) {
			if (classMotionFlag & ClassMotionFlag.ARCHER) {
				result = true;
			}
		}
		else if (weaponCategoryType === WeaponCategoryType.MAGIC) {
			if (classMotionFlag & ClassMotionFlag.MARGE) {
				result = true;
			}
		}
		
		return result;
	},
	
	// 後のバージョンで削除
	_isWeaponTypeAllowed: function(unit, item) {
		return false;
	},
	
	// 後のバージョンで削除
	_isOnlyData: function(unit, item) {
		return false;
	},
	
	// 後のバージョンで削除
	_isOnlyDataClass: function(cls, item) {
		return false;
	}
};

// unit.getItemなどの呼び出しをラッピングする
var UnitItemControl = {
	getItem: function(unit, index) {
		return unit.getItem(index);
	},
	
	setItem: function(unit, index, item) {
		unit.setItem(index, item);
	},
	
	cutItem: function(unit, index) {
		var item;
		
		// clearItemは、indexが示すアイテム位置はnullにする。
		// 戻り値は、以前に存在していたアイテム。
		item = unit.clearItem(index);
		
		this.arrangeItem(unit);
		
		return item;
	},
	
	// アイテムの順番を整頓する
	arrangeItem: function(unit) {
		var i, j, item;
		var count = this.getPossessionItemCount(unit);
		var maxCount = DataConfig.getMaxUnitItemCount();
		
		// 間に空白ができないようにアイテムを詰める
		for (i = 0; i < count; i++) {
			if (unit.getItem(i) === null) {
				for (j = i + 1; j < maxCount; j++) {
					item = unit.getItem(j);
					if (item !== null) {
						unit.setItem(i, item);
						unit.clearItem(j);
						break;
					}
				}
			}
		}
	},
	
	// unitのアイテム欄にitemを追加する
	pushItem: function(unit, item) {
		var count = this.getPossessionItemCount(unit);
		
		if (count < DataConfig.getMaxUnitItemCount()) {	
			this.arrangeItem(unit);
			unit.setItem(count, item);
			return true;
		}
		
		return false;
	},
	
	// unitが所持しているアイテムの数を返す
	getPossessionItemCount: function(unit) {
		var i;
		var count = DataConfig.getMaxUnitItemCount();
		var bringCount = 0;
		
		for (i = 0; i < count; i++) {
			if (unit.getItem(i) !== null) {
				bringCount++;
			}
		}
		
		return bringCount;
	},
	
	// アイテムを追加できるスペースがあるか調べる
	isUnitItemSpace: function(unit) {
		return this.getPossessionItemCount(unit) !== DataConfig.getMaxUnitItemCount();
	},
	
	getMatchItem: function(unit, targetItem) {
		var i, item, count;
		
		if (unit === null) {
			return null;
		}
		
		count = this.getPossessionItemCount(unit);

		// targetItemをunitが所持しているかを調べる
		for (i = 0; i < count; i++) {
			item = this.getItem(unit, i);
			if (item === targetItem) {
				return item;
			}
		}

		// 所持していない場合は、同一IDのアイテムを所持しているかを調べる
		for (i = 0; i < count; i++) {
			item = this.getItem(unit, i);
			if (ItemControl.compareItem(item, targetItem)) {
				return item;
			}
		}
		
		return null;
	},
	
	getIndexFromItem: function(unit, targetItem) {
		var i, item;
		var count = UnitItemControl.getPossessionItemCount(unit);
		
		for (i = 0; i < count; i++) {
			item = UnitItemControl.getItem(unit, i);
			if (item === targetItem) {
				return i;
			}
		}
		
		return -1;
	}
};

// root.getMetaSession().getStockItemArrayの呼び出しをラッピングする
var StockItemControl = {
	getStockItemArray: function() {
		return root.getMetaSession().getStockItemArray();
	},
	
	getStockItem: function(index) {
		var itemArray = this.getStockItemArray();
		return itemArray[index];
	},
	
	setStockItem: function(index, item) {
		var itemArray = this.getStockItemArray();
		
		itemArray[index] = item;
		this.sortItem();
	},
	
	pushStockItem: function(item) {
		var itemArray = this.getStockItemArray();
		
		itemArray.push(item);
		this.sortItem();
	},
	
	cutStockItem: function(index) {
		var itemArray = this.getStockItemArray();
		
		itemArray.splice(index, 1);
		this.sortItem();
	},
	
	getStockItemCount: function() {
		var itemArray = this.getStockItemArray();
		return itemArray.length;
	},
	
	isStockItemSpace: function() {
		return this.getStockItemCount() !== DataConfig.getMaxStockItemCount();
	},
	
	getMatchItem: function(targetItem) {
		var i, item;
		var count = this.getStockItemCount();
		
		for (i = 0; i < count; i++) {
			item = this.getStockItem(i);
			if (ItemControl.compareItem(item, targetItem)) {
				return item;
			}
		}
		
		return null;
	},
	
	getIndexFromItem: function(item) {
		var i;
		var count = this.getStockItemCount();
		
		for (i = 0; i < count; i++) {
			if (this.getStockItem(i) === item) {
				return i;
			}
		}
		
		return -1;
	},
	
	sortItem: function() {
		var itemArray = this.getStockItemArray();
		
		// 並び替えの優先順位は次のようになる。
		// ・武器はアイテムより優先
		// ・idが低いアイテムは高いアイテムより優先
		// ・耐久が低いアイテムは高いアイテムより優先
		itemArray.sort(
			function(item1, item2) {
				var id1, id2;
				var limit1, limit2;
				
				id1 = item1.getId();
				id2 = item2.getId();
				
				if (!item1.isWeapon()) {
					id1 += ItemIdValue.BASE;
				}
				
				if (!item2.isWeapon()) {
					id2 += ItemIdValue.BASE;
				}
				
				if (id1 > id2) {
					return 1;
				}
				else if (id1 < id2) {
					return -1;
				}
				else {
					limit1 = item1.getLimit();
					limit2 = item2.getLimit();
					
					if (limit1 > limit2) {
						return 1;
					}
					else if (limit1 < limit2) {
						return -1;
					}
				}
				
				return 0;
			}
		);
	}
};

var ItemChangeControl = {
	changeStockItem: function(targetItem, increaseType) {
		var arr = [];
		
		// arrにアイテムが格納された場合は、そのアイテムはストックに格納できない
		
		if (increaseType === IncreaseType.INCREASE) {
			arr = this._increaseStockItem(targetItem);
		}
		else if (increaseType === IncreaseType.DECREASE) {
			arr = this._decreaseStockItem(targetItem);
		}
		else if (increaseType === IncreaseType.ALLRELEASE) {
			arr = this._releaseAllStockItem();
		}
		
		return arr;
	},
	
	changeUnitItem: function(unit, targetItem, increaseType, isStockSend) {
		var arr = [];
		
		// arrにアイテムが格納された場合は、そのアイテムは所持またはストックに格納できない
		
		if (increaseType === IncreaseType.INCREASE) {
			arr = this._increaseUnitItem(unit, targetItem);
		}
		else if (increaseType === IncreaseType.DECREASE) {
			arr = this._decreaseUnitItem(unit, targetItem, isStockSend);
		}
		else if (increaseType === IncreaseType.ALLRELEASE) {
			arr = this._releaseAllUnitItem(unit, isStockSend);
		}
		
		return arr;
	},
	
	_increaseStockItem: function(targetItem) {
		var arr = [];
		
		if (!StockItemControl.isStockItemSpace()) {
			arr.push(targetItem);
			return arr;
		}
		
		StockItemControl.pushStockItem(targetItem);
		
		return arr;
	},
	
	_decreaseStockItem: function(targetItem) {
		var i, item;
		var count = StockItemControl.getStockItemCount();
		
		for (i = 0; i < count; i++) {
			item = StockItemControl.getStockItem(i);
			if (item !== null && ItemControl.compareItem(item, targetItem)) {
				StockItemControl.cutStockItem(i);
				break;
			}
		}
		
		return [];
	},
	
	_releaseAllStockItem: function() {
		var i;
		var count = StockItemControl.getStockItemCount();
		
		// 重要アイテムも含めて全て削除される
		for (i = 0; i < count; i++) {
			StockItemControl.cutStockItem(0);
		}
		
		return [];
	},
	
	_increaseUnitItem: function(unit, targetItem) {
		var arr = [];
		
		if (!UnitItemControl.isUnitItemSpace(unit)) {
			arr.push(targetItem);
			return arr;
		}
		
		UnitItemControl.pushItem(unit, targetItem);
		
		// 新しいアイテムを所持したため更新
		ItemControl.updatePossessionItem(unit);
		
		return arr;
	},
	
	_decreaseUnitItem: function(unit, targetItem, isStockSend) {
		var i, item, curItem;
		var count = DataConfig.getMaxUnitItemCount();
		var arr = [];
		
		for (i = 0; i < count; i++) {
			item = UnitItemControl.getItem(unit, i);
			if (ItemControl.compareItem(item, targetItem)) {
				// 同じアイテムが見つかったから消去
				curItem = UnitItemControl.cutItem(unit, i);
				if (curItem !== null && isStockSend) {
					if (StockItemControl.isStockItemSpace()) {
						StockItemControl.pushStockItem(curItem);
					}
					else {
						arr.push(curItem);
					}
				}
				break;
				
			}
		}
		
		return arr;
	},
	
	_releaseAllUnitItem: function(unit, isStockSend) {
		var i, curItem;
		var count = DataConfig.getMaxUnitItemCount();
		var arr = [];
		
		for (i = 0; i < count; i++) {
			curItem = UnitItemControl.cutItem(unit, 0);
			if (curItem !== null && isStockSend) {
				if (StockItemControl.isStockItemSpace()) {
					StockItemControl.pushStockItem(curItem);
				}
				else {
					arr.push(curItem);
				}
			}
		}
		
		return arr;
	}
	
};