const { graphql } = require("graphql");
const { schema } = require("tempus-api-graphql");
const fs = require('fs');

const sleep = (time) => {
  return new Promise((resolve) => setTimeout(resolve, time))
}

/*var DumpMapByID = async function(id) {
	const query = `
	{
  map(id: ${id}) {
    authors {
      name
      player {
        steamId
        country
      }
    }
    id
    name
    videos {
      soldier
      demoman
    }
    tiers {
      soldier
      demoman
    }
    zones {
      bonus {
        id
	map {
	  tiers {
	     soldier
	     demoman
	   }
	}
	type
	zoneindex
        customName
      }
      bonusEnd {
        id
	map {
	  tiers {
	     soldier
	     demoman
	   }
	}
	type
	zoneindex
        customName
      }
      checkpoint {
        id
	map {
	  tiers {
	     soldier
	     demoman
	   }
	}
	type
	zoneindex
        customName
      }
      course {
        id
	map {
	  tiers {
	     soldier
	     demoman
	   }
	}
	type
	zoneindex
        customName
      }
      courseEnd {
        id
	map {
	  tiers {
	     soldier
	     demoman
	   }
	}
	type
	zoneindex
        customName
      }
      linear {
        id
	map {
	  tiers {
	     soldier
	     demoman
	   }
	}
	type
	zoneindex
        customName
      }
      map {
        id
	map {
	  tiers {
	     soldier
	     demoman
	   }
	}
	type
	zoneindex
        customName
      }
      mapEnd {
        id
	map {
	  tiers {
	     soldier
	     demoman
	   }
	}
	type
	zoneindex
        customName
      }
      misc {
        id
	map {
	  tiers {
	     soldier
	     demoman
	   }
	}
	type
	zoneindex
        customName
      }
      trick {
        id
	map {
	  tiers {
	     soldier
	     demoman
	   }
	}
	type
	zoneindex
        customName
      }
    }
  }
}`;

    

    console.log(`Querying for map id: ${id}`)
    var result = await graphql(schema, query);
    await sleep(1000)
    if (result.errors && result.errors.length > 0) {
	if (result.errors[0].message && result.errors[0].message.search("404")) {
		var file_loc = `./data/404-result-${id}.json`;
    		var err = fs.writeFileSync(file_loc, "");
		if (err)
		    throw err;
		console.log(`Recieved graceful 404 on id: ${id}`);
	    return
	}
	console.log(`Errormap: ${JSON.stringify(result)}`)
	return
    }

    var name = `UnknownIDPleaseFix${id}`;
    if (result.data.map)
	name = result.data.map.name;

    console.log(`Found map: ${name}`)
    var file_loc = `./data/${name}.json`;
    var err = fs.writeFileSync(file_loc, JSON.stringify(result.data.map, null, "\t"));
    if (err) {
	console.log(err)
        throw err;
    }
    console.log(`Saved map \"${name}\" into \"${file_loc}\"`)
}*/

const DumpAllMapIds = async function() {
const query = `
	{
    maps {
        id
    }
}`;

    console.log("Querying for list of maps")
    var result = await graphql(schema, query);
    await sleep(1000)

    var sorted_maplist = [];
    for (var mapobj in result.data.maps)
	sorted_maplist.push(mapobj)
    sorted_maplist.sort();
   return sorted_maplist;
}

const GetRecordByPlayerMapID = async function(mapid, playerid, splits, soldier = true) {
	var tfclass = soldier ? "SOLDIER" : "DEMOMAN";
	var splitreq = !splits ? "" : `splits {
          customName
          duration
          comparedDuration
        }`;
	
	const query = `{
  player(id: ${playerid}) {
      record (mapId: ${mapid}, class: ${tfclass}){
        id
      	duration
      	rank
        date
        demo {
          filename
          url
          recording
          requested
          uploader {
            id
          }
        }
        class
      	demoStartTick
        demoEndTick
        server {
          id
          shortname
          name
          hostName
        }
        ${splitreq}
      }
  }
  map(id: ${mapid}) {
    name
  }
}`;

    console.log(`Querying for map records id: ${mapid}`)
    var result = await graphql(schema, query);
    await sleep(1000)
    if (result.errors && result.errors.length > 0) {
	var after_fourohfour = null;
	for (var i = 0; i < result.errors.length; i++) {
	   var err = result.errors[i];
	   if (err.message && err.message === "Request failed with status code 404") {
		var file_loc = `./data-records/404-result-${mapid}.json`;
	    	var fserr = fs.writeFileSync(file_loc, "");
		if (fserr)
			throw fserr;
		console.log(`Recieved graceful 404 on id: ${mapid}`);
		throw err.message;
	    } else 
		after_fourohfour = err;
	    //console.log(`Errormap: ${JSON.stringify(result)}`)
	}
	if (after_fourohfour)
		throw after_fourohfour;
	return
    }
    
    return result;
    /*var file_loc = `./data-records/${name}.json`;
    var err = fs.writeFileSync(file_loc, JSON.stringify(result.data.map, null, "\t"));
    if (err) {
	console.log(err)
        throw err;
    }
    console.log(`Saved map \"${name}\" into \"${file_loc}\"`)*/
}

const FindPlayerIdFromSteamId = async function(mapids, steamid) {
    for (var map_id in mapids) {
	try {
	var last_length = 25;
	for (var i = 1; last_length >= 25; i += 25) {
	    last_length = 0;
	    const query = `{
map(id: ${map_id}) {
    records(start: ${i}, class: SOLDIER) {
      player{
        id
        steamId
        name
      }
    }
}
}`;	
	    console.log(`Querying for map records: ${map_id} at ${i}`)
    	    var result = await graphql(schema, query);
    	    await sleep(1000)
    	    if (result.errors && result.errors.length > 0) 
		throw result.errors[0];
	    
	    if (result.data.map.records) {
	        last_length = result.data.map.records.length;
	        for (var ii = 0; ii < result.data.map.records.length; ii++) {
		    var record = result.data.map.records[ii];
		    if (record && record.player && record.player.steamId && record.player.steamId === steamid) {
		        console.log(`Found ID! ${record.player.id}`);
		        return record.player.id;
		    }
	        }
	    }
	}
	} catch (err) {
	    console.log(`Maprecords by id failed: ${map_id} with ${err}`);
	}
    }
}

const DumpAllRecordsFor = async function(mapids, playerid, soldier = true) {
    for (var map_id in mapids) {
	var result = {};
	try {
	    result = await GetRecordByPlayerMapID(map_id, playerid, true, soldier);
        } catch (err) {
	    if (err.message && err.message === "Request failed with status code 404")
		continue;
       	    if (err.message == "this.attrs.map_info is undefined" || err.message == "Cannot read properties of undefined (reading 'name')") {
		console.log(`Requerying without splits`);
	        try {
	    	    result = await GetRecordByPlayerMapID(map_id, playerid, false, soldier)
	        } catch (err) { 
		    console.log(`Error getting query ${map_id}: ${err}`);
		    continue; 
	        }
	    } else
		continue;
	}
	
	var name = `UnknownNamePleaseFixId${map_id}`;
    	if (result.data.map) {
		name = result.data.map.name;
		console.log(`Found map name: ${name}`)
	} else
	    console.log(`Falling back to mapid for name: ${id}`)

	if (result.data.player.record === null) {
	    console.log(`No record found for map: ${name}`);
	    var file_loc = `./data-non-records/${name}.json`;
	    var fserr = fs.writeFileSync(file_loc, "");
	    if (fserr)
		throw fserr;
	    continue;
	}

    	if (!result.data.player.record.name)
		result.data.player.record.name = name;

	/*var file_loc = `./data-records/${name}.json`;
	var err = fs.writeFileSync(file_loc, JSON.stringify(result.data.player.record, null, "\t"));
	if (err) {
	    console.log(err)
	    throw err;
	}
	console.log(`Saved map record\"${name}\" into \"${file_loc}\"`)*/
    }
}

var verboze = false; 
const DumpWorldRecord = async function(mapid, splits, soldier = true) {
	var tfclass = soldier ? "SOLDIER" : "DEMOMAN";
	var splitreq = !splits ? "" : `splits {
          customName
          duration
          comparedDuration
        }`;
	
	const query = `{
  map(id: ${mapid}) {
    name
    wr(class: ${tfclass}){
      player {
          name
          steamId
      }
      duration
      date
      demo {
        filename
        date
        url
        recording
        requested
        expired
        deleted
        uploader {
          steamId
          name
        }
        server {
        	id
          hostName 
          name
        }
      }
      demoStartTick
      demoEndTick
      server {
        id
        hostName 
        name
      }
      ${splitreq}
    }
  }
}`;
    if (verboze) {
    console.log("Dumping before query")
    console.log(query)	}
    console.log(`Querying for map wrs: ${mapid}`)
    var result = await graphql(schema, query);
    await sleep(1000)
    if (result.errors && result.errors.length > 0) {
	var after_fourohfour = null;
	for (var i = 0; i < result.errors.length; i++) { 
	   var err = result.errors[i];
	   if (verboze) {
	   console.log("Dumping errors")
	    console.log(err)	}
	   if (err.message && err.message === "Request failed with status code 404") {
		var file_loc = `./data-wr/404-result-${mapid}.json`;
	    	var fserr = fs.writeFileSync(file_loc, "");
		if (fserr)
			throw fserr;
		console.log(`Recieved graceful 404 on id: ${mapid}`);
		throw err.message;
	    } else 
		after_fourohfour = err;
	    //console.log(`Errormap: ${JSON.stringify(result)}`)
	}
	if (after_fourohfour)
		throw after_fourohfour;
	return
    }
    
    return result;
    /*var file_loc = `./data-records/${name}.json`;
    var err = fs.writeFileSync(file_loc, JSON.stringify(result.data.map, null, "\t"));
    if (err) {
	console.log(err)
        throw err;
    }
    console.log(`Saved map \"${name}\" into \"${file_loc}\"`)*/
}

const DumpAllWrs = async function(mapids, soldier = true) {
    for (var map_id in mapids) {
	var result = {};
	try {
	    result = await DumpWorldRecord(map_id, true, soldier);
        } catch (err) {
		if (verboze) {
            console.log("Dumping before retry")	
	    console.log(err)	}
	    if (err.message && err.message === "Request failed with status code 404")
		continue;
       	    if (err.message == "this.attrs.map_info is undefined" || err.message == "Cannot read properties of undefined (reading 'name')") {
		console.log(`Requerying without splits`);
	        try {
	    	    result = await DumpWorldRecord(map_id, false, soldier)
	        } catch (err) { 
		    console.log(`Error getting query ${map_id}: ${err}`);
		    continue; 
	        }
	    } else
		continue;
	}
	
	var name = `UnknownNamePleaseFixId${map_id}`;
    	if (result.data.map) {
		name = result.data.map.name;
		console.log(`Found map name: ${name}`)
	} else
	    console.log(`Falling back to mapid for name: ${id}`)

	if (result.data.map.wr === null) {
	    console.log(`No record found for map: ${name}`);
	    var file_loc = `./data-non-wr/${name}.json`;
	    var fserr = fs.writeFileSync(file_loc, "");
	    if (fserr)
		throw fserr;
	    continue;
	}

	var file_loc = `./data-wr/${name}.json`;
	var err = fs.writeFileSync(file_loc, JSON.stringify(result.data.map.wr, null, "\t"));
	if (err) {
	    console.log(err)
	    throw err;
	}
	console.log(`Saved map record\"${name}\" into \"${file_loc}\"`)
    }
}

async function main() {
	var mapids = await DumpAllMapIds()
	const playerid = 112000; // await FindPlayerIdFromSteamId(mapids, "STEAM_0:0:43167835");
	console.log(`Player Id: \"${playerid}\"`);
	await DumpAllWrs(mapids, false)
	//DumpAllRecordsFor(mapids, playerid)
	/* for (var map_id in mapids) {
	    console.log(map_id)
	    await DumpMapByID(map_id)
	}*/
	//DumpMapByID(97)
}
main();