import { Application } from "express";
import { Module } from "module";
import { prisma } from "..";
import { CarPathandTuning } from "@prisma/client";
import Long from "long";
import { Config } from "../config";
let MersenneTwister = require('chancer');

// Import Proto
import * as wm from "../wmmt/wm.proto";
import * as wmsrv from "../wmmt/service.proto";

// Import Util
import * as common from "../util/common";
import * as ghost_save_trail from "../util/ghost/ghost_save_trail";
import * as ghost_trail from "../util/ghost/ghost_trail";
import * as ghost_area from "../util/ghost/ghost_area";


export default class GhostModule extends Module {
    register(app: Application): void {

        // Load Ghost Battle Info
        app.post('/method/load_ghost_battle_info', async (req, res) => {

			// Get the request body for the load stamp target request
			let body = wm.wm.protobuf.LoadGhostBattleInfoRequest.decode(req.body); 

			let car = await prisma.car.findFirst({
				where:{
					carId: body.carId
				},
				include:{
					gtWing: true,
					lastPlayedPlace: true
				}
			})

			// Car History
			let findChallenger = await prisma.carChallenger.findMany({
				where: {
					challengerCarId: body.carId
				},
				orderBy:{
					lastPlayedAt: 'desc'
				},
				take: 10
			})

			let carsHistory: wm.wm.protobuf.Car[] = [];
			if(findChallenger.length > 0)
			{
				for(let i=0; i<findChallenger.length; i++)
				{
					let car = await prisma.car.findFirst({
						where: {
							carId: findChallenger[i].carId
						},
						include:{
							gtWing: true,
							lastPlayedPlace: true
						},
						orderBy: {
							carId: 'asc'
						},
						take: 10
					});

					carsHistory.push(wm.wm.protobuf.Car.create({
						...car!
					}))
				}
			}

			let carsStamp: wm.wm.protobuf.StampTargetCar[] = [];
			let carsChallenger: wm.wm.protobuf.ChallengerCar[] = [];

            // Get all of the friend cars for the carId provided
            let stampTargets = await prisma.carStampTarget.findMany({
                where: {
                    stampTargetCarId: body.carId,
					recommended: true
                },
				orderBy:{
					locked: 'desc'
				}
            });

			if(stampTargets)
			{
				for(let i=0; i<stampTargets.length; i++)
				{
					let carTarget = await prisma.car.findFirst({
						where:{
							carId: stampTargets[i].carId
						},
						include:{
							gtWing: true,
							lastPlayedPlace: true
						}
					})

					carsStamp.push(
						wm.wm.protobuf.StampTargetCar.create({
							car: carTarget!,
							returnCount: stampTargets[i].returnCount, 
							locked: stampTargets[i].locked, 
							recommended: stampTargets[i].recommended
						})
					);
				}
			}

			// Get all of the challenger car for the carId provided except beated car
			let checkBeatedCar = await prisma.carStampTarget.findMany({
                where: {
                    stampTargetCarId: body.carId,
					recommended: false
                },
				orderBy:{
					carId: 'asc'
				}
            });

			let arrChallengerCarId = [];
			for(let i=0; i<checkBeatedCar.length; i++)
			{
				arrChallengerCarId.push(checkBeatedCar[i].carId);
			}

            let challengers = await prisma.carChallenger.findMany({
                where: {
                    carId: body.carId,
					NOT: {
						challengerCarId: { in: arrChallengerCarId }, // Except beated challenger id
					},
                }
            });

			if(challengers)
			{
				for(let i=0; i<challengers.length; i++)
				{
					let carTarget = await prisma.car.findFirst({
						where:{
							carId: challengers[i].challengerCarId
						},
						include:{
							gtWing: true,
							lastPlayedPlace: true
						}
					})

					let result = 0;
					if(challengers[i].result > 0)
					{
						result = -Math.abs(challengers[i].result);
					}
					else{
						result = Math.abs(challengers[i].result);
					}

					carsChallenger.push(
						wm.wm.protobuf.ChallengerCar.create({
							car: carTarget!,
							stamp: challengers[i].stamp,
                            result: result, 
                            area: challengers[i].area
						})
					);
				}
			}

            // Response data
			let msg = {
				error: wm.wm.protobuf.ErrorCode.ERR_SUCCESS,
				stampTargetCars: carsStamp || null,
				challengers: carsChallenger || null,
				stampSheetCount: car!.stampSheetCount,
                stampSheet: car?.stampSheet || null, 
                stampReturnStats: car?.stampSheet || null,
				history: carsHistory || null,
			};

            // Encode the response
			let message = wm.wm.protobuf.LoadGhostBattleInfoResponse.encode(msg);

            // Send the response to the client
            common.sendResponse(message, res);
        })


        // Load Stamp Target
		app.post('/method/load_stamp_target', async (req, res) => {

            // Get the request body for the load stamp target request
			let body = wm.wm.protobuf.LoadStampTargetRequest.decode(req.body); 

			let carsStamp: wm.wm.protobuf.StampTargetCar[] = [];
			let carsChallenger: wm.wm.protobuf.ChallengerCar[] = [];

            // Get all of the friend cars for the carId provided
            let stampTargets = await prisma.carStampTarget.findMany({
                where: {
                    stampTargetCarId: body.carId,
					recommended: true
                },
				orderBy:{
					locked: 'asc'
				}
            });

			if(stampTargets)
			{
				for(let i=0; i<stampTargets.length; i++)
				{
					let carTarget = await prisma.car.findFirst({
						where:{
							carId: stampTargets[i].carId
						},
						include:{
							gtWing: true,
							lastPlayedPlace: true
						}
					})

					carsStamp.push(
						wm.wm.protobuf.StampTargetCar.create({
							car: carTarget!,
							returnCount: stampTargets[i].returnCount, 
							locked: stampTargets[i].locked, 
							recommended: stampTargets[i].recommended
						})
					);
				}
			}

			// Get all of the friend cars for the carId provided
            let challengers = await prisma.carChallenger.findMany({
                where: {
                    carId: body.carId
                }
            });

			if(stampTargets)
			{
				for(let i=0; i<challengers.length; i++)
				{
					let carTarget = await prisma.car.findFirst({
						where:{
							carId: challengers[i].challengerCarId
						},
						include:{
							gtWing: true,
							lastPlayedPlace: true
						}
					})

					let result = 0;
					if(challengers[i].result > 0)
					{
						result = -Math.abs(challengers[i].result);
					}
					else{
						result = Math.abs(challengers[i].result);
					}

					carsChallenger.push(
						wm.wm.protobuf.ChallengerCar.create({
							car: carTarget!,
							stamp: challengers[i].stamp,
                            result: result, 
                            area: challengers[i].area
						})
					);
				}
			}

            // Response data
			let msg = {
				error: wm.wm.protobuf.ErrorCode.ERR_SUCCESS,
				cars: carsStamp,
				challengers: carsChallenger
			};

			// Encode the response
            let message = wm.wm.protobuf.LoadStampTargetResponse.encode(msg);

            // Send the response to the client
            common.sendResponse(message, res);
		})


        // Ghost Mode
        app.post('/method/search_cars_by_level', async (req, res) => {

            // Get the request body for the search cars by level request
            let body = wm.wm.protobuf.SearchCarsByLevelRequest.decode(req.body);

			let car;

			if(body.regionId !== null && body.regionId !== undefined && body.regionId !== 0)
			{
				// Find ghost car by selected level and region ID
				car = await prisma.car.findMany({
					where: {
						ghostLevel: body.ghostLevel,
						regionId: body.regionId
					},
					include:{
						gtWing: true,
						lastPlayedPlace: true,
					}
				});
			}
			else
			{
				// Find ghost car by selected level
				car = await prisma.car.findMany({
					where: {
						ghostLevel: body.ghostLevel,
					},
					include:{
						gtWing: true,
						lastPlayedPlace: true,
					}
				});
			}

			// Randomizing the starting ramp and path based on selected area
			let rampVal = 0;
			let pathVal = 0;

			// Get the ramp and path id
			let ghost_areas = await ghost_area.GhostArea(body.area);

			// Set the value
			rampVal = ghost_areas.rampVal;
			pathVal = ghost_areas.pathVal;

			// Empty list of ghost car records
			let lists_ghostcar: wm.wm.protobuf.GhostCar[] = [];
			let arr = [];
			let maxNumber = 0;

            // If all user car data available is more than 10 for certain level
			if(car.length > 10)
			{ 
				maxNumber = 10 // Limit to 10 (game default)
			}
            // If no more than 10
			else
			{
				maxNumber = car.length;
			}

            // Choose the user's car data randomly to appear
			while(arr.length < maxNumber)
			{ 
                // Pick random car Id
				let randomNumber = MersenneTwister.int(0, car.length-1);
				
				if(arr.indexOf(randomNumber) === -1)
				{
                    // Push current number to array
					arr.push(randomNumber); 

                    // Check if ghost trail for certain car is available
					let ghost_trails = await prisma.ghostTrail.findFirst({
						where: {
							carId: car[randomNumber].carId,
							area: body.area,
							crownBattle: false
						},
						orderBy: {
							playedAt: 'desc'
						}
					});

                    // If regionId is 0 or not set, game will crash after defeating the ghost
					if(car[randomNumber]!.regionId === 0)
					{
						car[randomNumber].regionId = MersenneTwister.int(1, 47);
					}

                    // Push user's car data without ghost trail
					if(!(ghost_trails))
					{ 
						lists_ghostcar.push(wm.wm.protobuf.GhostCar.create({
							car: car[randomNumber]
						}));
					}
                    // Push user's car data with ghost trail
					else
					{
                        // Set the tunePower used when playing certain area
						car[randomNumber].tunePower = ghost_trails!.tunePower;

                        // Set the tuneHandling used when playing certain area
						car[randomNumber].tuneHandling = ghost_trails!.tuneHandling;

                        // Push data to Ghost car proto
						lists_ghostcar.push(wm.wm.protobuf.GhostCar.create({
							car: car[randomNumber],
							nonhuman: false,
							type: wm.wm.protobuf.GhostType.GHOST_NORMAL,
							trailId: ghost_trails!.dbId!
						}));
					}
				}
			}

			// Check again if car list for that selected region is available of not
			if(body.regionId !== null && body.regionId !== undefined && body.regionId !== 0)
			{
				if(car.length < 1)
				{
					// Get current date
					let date = Math.floor(new Date().getTime() / 1000);
					let playedPlace = wm.wm.protobuf.Place.create({ 
						placeId: Config.getConfig().placeId,
						regionId: Config.getConfig().regionId,
						shopName: Config.getConfig().shopName,
						country: Config.getConfig().country
					});

					let tunePowerDefault = 0
					let tuneHandlingDefault = 0;
					if(body.ghostLevel === 1)
					{
						tunePowerDefault = 1;
						tuneHandlingDefault = 4;
					}
					else if(body.ghostLevel === 2)
					{
						tunePowerDefault = 5;
						tuneHandlingDefault = 5;
					}
					else if(body.ghostLevel === 3)
					{
						tunePowerDefault = 8;
						tuneHandlingDefault = 7;
					}
					else if(body.ghostLevel === 4)
					{
						tunePowerDefault = 10;
						tuneHandlingDefault = 10;
					}
					else if(body.ghostLevel === 5)
					{
						tunePowerDefault = 15;
						tuneHandlingDefault = 10;
					}
					else if(body.ghostLevel === 6)
					{
						tunePowerDefault = 18;
						tuneHandlingDefault = 10;
					}
					else if(body.ghostLevel === 7)
					{
						tunePowerDefault = 20;
						tuneHandlingDefault = 10;
					}
					else if(body.ghostLevel === 8)
					{
						tunePowerDefault = 21;
						tuneHandlingDefault = 10;
					}
					else if(body.ghostLevel === 9)
					{
						tunePowerDefault = 22;
						tuneHandlingDefault = 10;
					}
					else if(body.ghostLevel === 10)
					{
						tunePowerDefault = 24;
						tuneHandlingDefault = 10;
					}
					else if(body.ghostLevel === 11)
					{
						tunePowerDefault = 24;
						tuneHandlingDefault = 24;
					}

					// Generate default S660 car data
					car = wm.wm.protobuf.Car.create({ 
						carId: 999999999, // Don't change this
						name: 'Ｓ６６０',
						regionId: body.regionId, // IDN (福井)
						manufacturer: 12, // HONDA
						model: 105, // S660 [JW5]
						visualModel: 130, // S660 [JW5]
						defaultColor: 0,
						customColor: 0,
						wheel: 20,
						wheelColor: 0,
						aero: 0,
						bonnet: 0,
						wing: 0,
						mirror: 0,
						neon: 0,
						trunk: 0,
						plate: 0,
						plateColor: 0,
						plateNumber: 0,
						tunePower: tunePowerDefault,
						tuneHandling: tuneHandlingDefault,
						rivalMarker: 32,
						aura: 551,
						windowSticker: true,
						windowStickerString: 'ＢＡＹＳＨＯＲＥ',
						windowStickerFont: 0,
						title: 'No Ghost for this Region',
						level: 65, // SSSSS
						lastPlayedAt: date,
						country: 'JPN',
						lastPlayedPlace: playedPlace
					});

					// Push data to Ghost car proto
					lists_ghostcar.push(wm.wm.protobuf.GhostCar.create({
						car: car,
						nonhuman: true,
						type: wm.wm.protobuf.GhostType.GHOST_DEFAULT,
					}));
				}

				// else{} have car list
			}

            // Response data
			let msg = {
				error: wm.wm.protobuf.ErrorCode.ERR_SUCCESS,
				ramp: rampVal,
				path: pathVal,
				ghosts: lists_ghostcar,
				selectionMethod: Number(wm.wm.protobuf.GhostSelectionMethod.GHOST_SELECT_BY_LEVEL)
			};

			// Encode the response
            let message = wm.wm.protobuf.SearchCarsByLevelResponse.encode(msg);

            // Send the response to the client
            common.sendResponse(message, res);
        })


        // Load Normal Ghost Trail data
        app.post('/method/load_ghost_drive_data', async (req, res) => {

            // Get the request body for the load ghost drive data request
            let body = wm.wm.protobuf.LoadGhostDriveDataRequest.decode(req.body);

            // Get the path value from request body
			let path = body.path;

			// Empty list of ghost drive data records
			let lists_ghostcar: wm.wm.protobuf.LoadGhostDriveDataResponse.GhostDriveData[] = [];

            // Check how many opponent ghost data available (including user data)
			for(let i=0; i<body.carTunings.length; i++)
			{ 
                // Check if opponent ghost have trail
				let ghost_trails = await prisma.ghostTrail.findFirst({ 
					where: {
						carId: body.carTunings[i].carId!,
						path: body.path,
					},
					orderBy: {
						playedAt: 'desc'
					}
				});
				
				// ---Get the user and opponent ghost trail data---
				let ghostType: number = wm.wm.protobuf.GhostType.GHOST_NORMAL;
				let lists_binarydriveData;
				if(ghost_trails?.driveData !== null && ghost_trails?.driveData !== undefined){
					lists_binarydriveData = wm.wm.protobuf.BinaryData.create({
						data: ghost_trails!.driveData!,
						mergeSerial: ghost_trails!.driveDMergeSerial!
					});
				}

				let lists_binaryByArea
				if(ghost_trails?.trendBinaryByArea !== null && ghost_trails?.trendBinaryByArea !== undefined){
					lists_binaryByArea = wm.wm.protobuf.BinaryData.create({
						data:  ghost_trails!.trendBinaryByArea!,
						mergeSerial: ghost_trails!.byAreaMergeSerial!
					});
				}

				let lists_binaryByCar
				if(ghost_trails?.trendBinaryByCar !== null && ghost_trails?.trendBinaryByCar !== undefined){
					lists_binaryByCar = wm.wm.protobuf.BinaryData.create({
						data: ghost_trails!.trendBinaryByCar!,
						mergeSerial: ghost_trails!.byCarMergeSerial!
					});
				}

				let lists_binaryByUser
				if(ghost_trails?.trendBinaryByUser !== null && ghost_trails?.trendBinaryByUser !== undefined){
					lists_binaryByUser = wm.wm.protobuf.BinaryData.create({
						data: ghost_trails!.trendBinaryByUser!,
						mergeSerial: ghost_trails!.byUserMergeSerial!
					});
				}
				// ------------------------------------------------


                // Push the data
				lists_ghostcar.push(wm.wm.protobuf.LoadGhostDriveDataResponse.GhostDriveData.create({ // Push the data
					carId: Number(body.carTunings[i].carId!),
					type: ghostType,
					driveData: lists_binarydriveData || null,
					trendBinaryByArea: lists_binaryByArea || null,
					trendBinaryByCar: lists_binaryByCar || null,
					trendBinaryByUser: lists_binaryByUser || null,
				}));
			}

            // Response data
			let msg = {
				error: wm.wm.protobuf.ErrorCode.ERR_SUCCESS,
				path: path,
				data: lists_ghostcar
			};

            // Encode the response
			let message = wm.wm.protobuf.LoadGhostDriveDataResponse.encode(msg);
            
            // Send the response to the client
            common.sendResponse(message, res);
        })


        // Saving the ghost trail on mileage screen
		app.post('/method/register_ghost_trail', async (req, res) => {

            // Get the request body for the register ghost trail request
			let body = wm.wm.protobuf.RegisterGhostTrailRequest.decode(req.body);

            // Get the session id
			let actualSessionId: number = 0;

			// If the session are set, and are long data
            if(Long.isLong(body.ghostSessionId))
            {
                // Convert them to BigInt and add to the data
                actualSessionId = common.getBigIntFromLong(body.ghostSessionId);
            }

            // OCM game mode session id
			if(actualSessionId > 100 && actualSessionId < 201)
			{ 
				console.log('OCM Ghost Battle Game found');

				// User playing ocm battle game mode
				await ghost_save_trail.saveOCMGhostTrail(body);
			}
            // Ghost Battle or Crown Ghost Battle game Mode session id
			else if(actualSessionId > 0 && actualSessionId < 101)
			{
                // Check if it is crown ghost battle or not (crown ghost battle don't have time, driveData, trendBinaryByArea, trendBinaryByCar, trendBinaryByUser value from request body)
				if(!(body.trendBinaryByArea) && !(body.trendBinaryByCar) && !(body.trendBinaryByUser))
				{
					console.log('Crown Ghost Battle Game found');

					// User is playing crown ghost battle game mode
					await ghost_save_trail.saveCrownGhostTrail(body);
				}
				else
				{
					console.log('Normal Ghost Battle Game found');

					// User is playing normal ghost battle game mode
					await ghost_save_trail.saveNormalGhostTrail(body);

					// Saving Ghost Path and Tuning
					await ghost_save_trail.savePathAndTuning(body);
				}
			}
	
            // Response data
			let msg = {
				error: wm.wm.protobuf.ErrorCode.ERR_SUCCESS
			}
			
			// Encode the response
            let message = wm.wm.protobuf.RegisterGhostTrailResponse.encode(msg);

            // Send the response to the client
            common.sendResponse(message, res);
		})


        // Load Crown Ghost Trail or Top 1 OCM Ghost Trail
		app.get('/resource/ghost_trail', async (req, res) => {	

            // Get url query parameter [For Crown Ghost Battle]
			let pCarId = Number(req.query.car_id);
			let pArea = Number(req.query.area); 

            // Get url query parameter [For OCM Ghost Battle]
			let pTrailId = Number(req.query.trail_id) || undefined;

			// Declare variable
			let rampVal: number = 0;
			let pathVal: number = 0;
			let playedAt: number = 0;
			let ghostTrail;

            // Query parameter from OCM Battle available
			if(pTrailId)
			{ 
				console.log('Requesting OCM Ghost Trail');

                // Get the trail data
				let ghost_trails = await ghost_trail.getOCMGhostTrail(pCarId, pTrailId);

				pArea = ghost_trails.areaVal;
				rampVal = ghost_trails.rampVal;
				pathVal = ghost_trails.pathVal;
				playedAt = ghost_trails.playedAt;
				ghostTrail = ghost_trails.ghostTrail;
			}
            // Query parameter from Crown Ghost Battle available
			else
			{ 
				console.log('Requesting Crown Ghost Trail');

				// Get the crown trail data
				let ghost_trails = await ghost_trail.getCrownGhostTrail(pCarId, pArea);

				rampVal = ghost_trails.rampVal;
				pathVal = ghost_trails.pathVal;
				playedAt = ghost_trails.playedAt;
				ghostTrail = ghost_trails.ghostTrail;
			}

            // Response data
			let msg = {
				carId: pCarId,
				area: pArea,
				ramp: rampVal,
				path: pathVal,
				playedAt: playedAt,
				trail: ghostTrail
			};
			
			// Encode the response
            let message = wm.wm.protobuf.GhostTrail.encode(msg);

            // Send the response to the client
            common.sendResponse(message, res);
		})


        // Load ghost path and tunings per area 
		app.post('/method/load_paths_and_tunings', async (req, res) => {

            // Get the request body for the load path and tunings request
			let body = wm.wm.protobuf.LoadPathsAndTuningsRequest.decode(req.body);

			// Empty list of car path and tuning records
			let carTbyP: wm.wm.protobuf.LoadPathsAndTuningsResponse.CarTuningsByPath[] = [];

            // Loop GID_RUNAREA_*
			for(let j=0; j<19; j++)
			{
                // 14 - 16 are dummy area, 17 is C1 Closed
				if(j >= 14){
					j = 18; // GID_RUNAREA_HIROSHIMA
				}
				let rampVal = 0;
				let pathVal = 0;

				// Get the ramp and path id
				let ghost_areas = await ghost_area.GhostArea(j);

				// Set the value
				rampVal = ghost_areas.rampVal;
				pathVal = ghost_areas.pathVal;

				// Empty list of car tuning records
				let carTuning: wm.wm.protobuf.CarTuning[] = [];
				let pathAndTuning: CarPathandTuning | null;

                // Loop to how many opponent ghost selected by user
				for(let i=0; i<body.selectedCars.length; i++)
				{ 
                    // Get path and tuning per area
					pathAndTuning = await prisma.carPathandTuning.findFirst({
						where: {
							carId: body.selectedCars[i],
							area: j
						},
						orderBy: {
							area: 'asc'
						}
					});

                    // Opponent ghost have path and tuning record for certain area
					if(pathAndTuning)
					{
                        // Push the data
						carTuning.push(wm.wm.protobuf.CarTuning.create({ 
							carId: body.selectedCars[i],
							tunePower: pathAndTuning!.tunePower,
							tuneHandling: pathAndTuning!.tuneHandling,
							lastPlayedAt: pathAndTuning!.lastPlayedAt,
						}));
					}
                    // Opponent ghost doesn't have path and tuning record for certain area
					else
					{ 
                        // Get user's car last used tunePower and tuneHandling
						let car = await prisma.car.findFirst({ 
							where: {
								carId: body.selectedCars[i]
							},
							select:{
								tunePower: true,
								tuneHandling: true
							}
						});	

                        // Push the data
						carTuning.push(wm.wm.protobuf.CarTuning.create({ 
							carId: body.selectedCars[i],

                            // Set the tunePower used when last played the game
							tunePower: car!.tunePower, 

                            // Set the tuneHandling used when last played the game
							tuneHandling: car!.tuneHandling 
						}));
					}
				}

                // Push the data
				carTbyP.push(wm.wm.protobuf.LoadPathsAndTuningsResponse.CarTuningsByPath.create({
					area: j,
					ramp: rampVal,
					path: pathVal,
					carTunings: carTuning,
					selectionMethod: wm.wm.protobuf.PathSelectionMethod.PATH_NORMAL // idk what this is
				}));
			}

            // Response data
            let msg = {
				error: wm.wm.protobuf.ErrorCode.ERR_SUCCESS,
				data: carTbyP
			};

            // Encode the response
			let message = wm.wm.protobuf.LoadPathsAndTuningsResponse.encode(msg);

			// Send the response to the client
            common.sendResponse(message, res);
		})


        // Lock Crown
        app.post('/method/lock_crown', (req, res) => {

			// Get the information from the request
			let body = wmsrv.wm.protobuf.LockCrownRequest.decode(req.body);

            // Response data
            let msg = {
				error: wmsrv.wm.protobuf.ErrorCode.ERR_SUCCESS,
			};

            // Encode the response
			let message = wmsrv.wm.protobuf.LockCrownResponse.encode(msg);

			// Send the response to the client
            common.sendResponse(message, res);
        })
    }
}