// Need to require DB again. Apparently this is ok, as it'll
// still only have one require cross project (?)
const database = require('./database');


// cardClass, cardColourRequirement 
// may want to be seperate too (as well as in cardItem), so that
// during match they can be altered by effects while keeping the OG card
// for inspecting (and compare against new stats,reqs,etc.)
// same with attack, cost, etc. things that will can be visually shown as
// changed in game

// Just grabbing everything from DB for now, as it's quite small at current
// then will rejig when needed.
// Should all cards, effects, classes etc. be loaded in on server start
// then just load decks and decklists when needed?
function getDecks(deckIds = false){
	// Await promise, once it's done get the data, if errors send err
	const dPromise = new Promise((resolve, reject) => {

		database.dbGetDecks().then(data => {

			let decks = [];

			data.forEach((deck) => {
				//let itemId = item.length;
				//item.push(itemId); // Add the next available item
				// Add the deck info to deckItem
				// deckItem[itemId] = {};
				decks.push({
					'deckId': deck.deckId,
					'playerId': deck.playerId,
					'deckName': deck.deckName,
				});
			});

			// Resolve the decks pulled
			resolve(decks);

			//console.log(item);
			//console.log(deckItem);
			//console.log(decks);
		})
		.catch(err => { throw err; })

	});
	return dPromise;
}
//getDecks();
function getDeckList(){
	const dPromise = new Promise((resolve, reject) => {

		database.dbGetDeckList().then(data => {

			let deckList = [];

			data.forEach((listItem) => {
				// Add the deck info to deckItem
				deckList.push({
					'deckId': listItem.deckId,
					'playerId': listItem.playerId,
					'cardId': listItem.cardId,
					'cardCount': listItem.cardCount,
				});
				resolve(deckList);
			});
		})
		.catch(err => { throw err; })
	});
	return dPromise;
}
//getDeckList();
function getCards(){
	const dPromise = new Promise((resolve, reject) => {

		database.dbGetCards().then(data => {

			let cards = [];

			data.forEach((card) => {
				cards.push({
					'id': card.id,
					'cardName': card.cardName,
					'cardCost': card.cardCost,
					'cardType': card.cardType,
					'cardAttack': card.cardAttack,
					'cardRarity': card.cardRarity,
					'cardClass': [],
					'cardColourRequirement': [],
				});
			});
			resolve(cards);
		})
		.catch(err => { throw err; })

	});
	return dPromise;
}
//getCards();
function getCardClasses(){
	const dPromise = new Promise((resolve, reject) => {
		database.dbGetCardClasses().then(data => {
			
			let cardClasses = [];

			data.forEach((cardClass) => {

				cardClasses.push({
					'cardId': cardClass.cardId,
					'classId': cardClass.classId,
				});

			});
			resolve(cardClasses);
		})
		.catch(err => { throw err; })
	});
	return dPromise;
}
//getCardClasses();
function getCardColourRequirement(){
	const dPromise = new Promise((resolve, reject) => {
		database.dbGetCardColourRequirement().then(data => {

			let colourRequirements = [];

			data.forEach((cardColourReq) => {

				colourRequirements.push({
					'cardId': cardColourReq.cardId,
					'colourId': cardColourReq.colourId,
					'cost': cardColourReq.cost,
				});

			});
			resolve(colourRequirements);

		})
		.catch(err => { throw err; })
	});
	return dPromise;
}
//getCardColourRequirement();
// Then effects which will have effects with parent triggers, and unit type checks
// colour checks, all sorts. So will be more difficult. Basic (flight, etc) 
// shouldn't be too bad
// something like effect_basic, card_effect, effect_trigger, effect_requirement, effect_option
// effect_stage, effect_advanced, with advanced being an id with x triggers, triggers have
// x req, advanced as with x options, x stages to be able to fine-tune fancy stuff 
// combining all other effects, units, cards, colours, etc. Will be a lot of though,
// but better than hard coding anything more than basic effects and effect check logic
// TODO: effect (as above)

// request a deck in the format CURRENTLY used in the game
// decks will likely be changed around

// https://www.geeksforgeeks.org/how-to-wait-for-multiple-promises-in-javascript/
// https://medium.com/@nikolozz/using-socket-io-with-async-await-13fa8c2dc9d9
// using last example
// TODO: When this is functionally working, need to split up into other func/modules
// such as: playerMod, cardMod, deckMod, miscMod ?
function requestDeck(socket, playerId, deckId){
	return new Promise((resolve, reject) => {
	(async () => {

	// Get the deck(s) requested.
	// Not 100% on how to do two differening atm
	// Besides all of playerId, and all of deckId. But 1,2/2,3 for instance
	const [decks, deckList] =
		await Promise.all([
			getDecks(),
			getDeckList()
		]);

	//console.log(decks);
	//console.log(deckList);
	// Now loop the deckList for the cardIds
	let deckCardIds = [];
	deckList.forEach((deckItem) => {
		deckCardIds.push(deckItem.cardId);

	});
	//console.log(deckCardIds);

	// Next, get the cards in the deck by their ID
	// TODO: https://stackoverflow.com/a/65510676
	// Change SQL to accept for just the cards passed

	// Get each cards data, colourReqs, and classes
	const [cards, cardClasses, cardColourRequirements] =
		await Promise.all([
			getCards(),
			getCardClasses(),
			getCardColourRequirement(),
		]);
	// ^^^^ Classes async? Can pass the cardsIds, then loop classes, if the class cardId
	// matches the cardId in cards[] then push the class to cards[x].classes

	// TODO: Build the card so far async for it's done alongside getting effects?
	// Then when both done add the effects to the existing cardObjects? Yep good idea me
	//console.log(cards);
	//console.info(cardClasses);
	//console.log(cardColourRequirements);

	const [builtCards] =
		await Promise.all([
			buildCards(cards, cardClasses, cardColourRequirements),
			// TODO: builtEffects
		]);

	//console.log(builtCards);
	// TODO: addEffectsToCards
	// TODO: Finally do the effects for each card. This will be the complicater
	// since it's not 100% thought out yet... (

	// Add the cards (x of how many cardObjects with cardId are in count in decklist)
	// to a deck array to pass through. Or decks array with deckId specified?
	//console.log(deckList);
	// These are the four basic fellas for this
	// from public/board.js where current game testing/logic is applied
	// So creating as a test for a 'room' to see if it's simple enough to
	// send and play with
	// BUILD THE DATA TO SEND TO CLIENTS! (Kinda)
	let item = [];
	let itemCount = 0; // TODO: Have this continue from last function (ie. getPlayers?)
	let deckData = {}; // New but may be useful
	let deckIn = {}; // Which deck the item is in? Kinda the player/boardelement thing?
	let cardData = {};
	let boardElement = {};
	// TODO: Set the player. For now will do this in front-end as testing currently

	// Loop and create the deck first
	//console.log(decks);
	decks.forEach((deck) => {
		item.push(itemCount); // Add new item to add stuff for
		deckData[itemCount] = {'deckId':deck.deckId, 'playerId':deck.playerId, 'deckName':deck.deckName};
		boardElement[itemCount] = 'realDeck';
		itemCount++;
	})
	console.log(deckData);
	console.log(deckList);

	// Loop each item in the deckList
	// Loop inside it X times where X is cardCount
	// Add the builtCard with same cardId as deckList item X times
	deckList.forEach((deckListItem) => {

		let deckItem = null;
		// Loop each deck, if the deck/playerIds match, add association
		for(key in deckData){
		//Object.keys(deckData).forEach(function(key) { // Less efficient than for
			// Needs to check deck AND player id, as that's the primary key (together)
			if(deckData[key].deckId == deckListItem.deckId && deckData[key].playerId == deckListItem.playerId){
				deckItem = key; // Key is the `item` key
			}
			
		};
		// For each new card, loop to the cardCount (how many cards in deck)
		// and add to the deck
		for(let i = 0; i < deckListItem.cardCount; i++){
			item.push(itemCount); // Add new item to add stuff for
			// ^ not using item.length incase anything in future gets deleted
			// from item for instance
			cardData[itemCount] = builtCards[deckListItem.cardId]; // builtCards id set to cardId from DB, so adding the builtCard object is based on the deckList's cardId (from DB)
			boardElement[itemCount] = 'deck'; // Add all cards to deck at match start
			// Associate the card with the deck
			// TODO: Change deckIn to something more sensical
			deckIn[itemCount] = deckItem;
			itemCount++; // Increment item to not overwrite
		}

	});

	// item, itemCount, deckData, cardData, boardElement
	//console.log(cardData);
	
	// Returning everything to be looped in the front-end
	// This won't be looped as it will at final, instead just for deck generation
	// Returned as object over array, as easier to disect when gets to front-end
	let dataReturn = {
		item: item,
		itemCount: itemCount,
		deckData: deckData,
		deckIn: deckIn,
		cardData: cardData,
		boardElement: boardElement,
	};
	return resolve(dataReturn);
	//return resolve(cardData);

	// Promise stuff testing
	})()
	});

	// TODO: In future the item inc. all the decks, cards, locations, and other attributes
	// will come from here

	// TODO: unrelated, but thought. If lots of players on, generating cards each time
	// will be a big hit, as well as all the DB hits, so may need to load all cardObjects
	// into memory/array when server starts. This then prevents any DB changes to alter
	// things, but outside of testing that won't occur(?), may need to test this at some
	// point to see. For now DB, and generating is ok, as still working on it
}

function buildCards(cards, cardClasses, cardColourRequirements){

	const dPromise = new Promise((resolve, reject) => {

		builtCards = {};

		//console.log(cards);
		// Loop the cards and build the base
		cards.forEach((card) => {

			let builtCard = {
				id: card.id,
				name: card.cardName,
				colour: [],
				cost: card.cardCost,
				costReq: [],
				type: card.cardType,
				atk: card.cardAttack,
				rarity: card.cardRarity,
				effect: [],
				cardClass: [],
			};
			// Give the card an easily accessible Id for compares
			// and to add to the cardItem being built
			builtCards[card.id] = builtCard;

		});
		//console.log(builtCards);

		// Next loop each class, and add to the new builtCard (if cardIds match)
		cardClasses.forEach((cardClass) => {

			// Check the card exists (it should always, but don't want jank)
			if(cardClass.cardId in builtCards){
				// It's the Id for now
				// TODO: Send the text too (from join) but don't use for compares
				//console.log(cardClass.cardId);
				//console.log(cardClass.classId);
				//console.log('---');
				//console.log(builtCards[cardClass.cardId]);

				// Add the class to the class array (cards can have multiple)
				builtCards[cardClass.cardId].cardClass.push(cardClass.classId);

				// TODO: As an array [classId, className] then 
				// card.classes[x][0] can be compared as numeric in code
			}

		});

		resolve(builtCards);

	});
	return dPromise;
}
// TODO: Add the effects onto the cards passed through
// Takes cards array (of obj), and array of effects (from DB or built, probabaly pre-built?)
function addCardsEffects(){}

module.exports = {
	requestDeck
};