const steem = require("steem");
const fetch = require("node-fetch");
const md5 = require("md5");
const KEYS = require("./keysS.json");
const cardData = require("./cardData.json");
var gamesPlayed = 0;
var delay = 20000;
var txId;
var err = 0;

class Battle {
  constructor(callback, appName = "smitopbot-public/1.0.0", matchType = "Ranked") {

    this.callback = callback;
    this.status = {};
    this.submittedTeam = false;

    console.log("Quest Name: ")
    checkQuest()
    setTimeout(function() {
    console.log(KEYS.dolochanusername+"'s Rating: ");
            checkRating();

          }, 1700);

    //broadcast sm_find_match
    steem.broadcast.customJson(KEYS.dolochanposting, [], [KEYS.dolochanusername], "sm_find_match", JSON.stringify({
      match_type: matchType,
      app: appName
    }), (err, result) => {
      if (err) throw err;
      console.log("Broadcasted sm_find_match");
      this.findMatchId = result.id;
    });
    //start /battle/status check loop
    this._checkInterval = setInterval(() => {
      this._checkBattleStatus();
    }, 2500);

  }
  end() {
    this.ended = true;
    clearInterval(this._checkInterval);
  }

  setTeam(team) {
    this.team = team;
  }
  broadcastTeam(summoner, monsters, skipReveal = false) {
    const secret = Battle.generatePassword();
    const teamHash = md5(summoner + "," + monsters.join() + "," + secret)
    const team = {
      summoner,
      monsters,
      secret
    };

    this.submittedTeam = true;
    var data = {
      trx_id: this.findMatchId,
      app: this.appName,
      team_hash: teamHash
    };

         txId = data.trx_id


    if (skipReveal) {
      data.summoner = summoner;
      data.monsters = monsters;
    }
    steem.broadcast.customJson(KEYS.dolochanposting, [], [KEYS.dolochanusername], "sm_submit_team", JSON.stringify(data), async (err, result) => {
      if (err) throw err;
      console.log("Broadcasted sm_submit_team");
      this.findMatchId = result.id;
      if (!skipReveal) {
        await new Promise(resolve => setTimeout(resolve, 3300));
        console.log("Revealing team...");

        steem.broadcast.customJson(KEYS.dolochanposting, [], [KEYS.dolochanusername], "sm_team_reveal", JSON.stringify({
          ...data,
          summoner: summoner,
          monsters: monsters,
          secret: secret,
          app: "smitopbot-public/1.0.0"
        }), (err, result) => {
          console.log("Revealed team!");
          gamesPlayed++;
          console.log("Games played:", gamesPlayed);

var battleover;

var myVar = setInterval(function() {
  battleover = checkBattle(txId, myVar);

  battleover.then(function(result) {
if (result === true){
clearInterval(myVar)
err = 0
    main();
  }
});
         }, 5000);



        });
      }



    });



  }

  _revealTeam() {

  }
  async _checkBattleStatus() {
    if (!this.findMatchId) return;
    const rawResponse = await fetch("https://api.steemmonsters.io/battle/status?id=" + this.findMatchId);
    const json = await rawResponse.json();
    this.status.data = json;

    if ((typeof json) === "string") {
      console.log(json);
      err = err+1
    if(err>9){
      err=0
    this.ended = true;
    clearInterval(this._checkInterval);
    main()
    }
      this.status.statusName = "battleTxProcessing";
      this.callback(this.status);
      return;
    }

    if (json.error) {
      this.status.statusName = "error";
      main();
    } else if (json.status === 0) {
      this.status.statusName = "searchingForEnemy";
    } else if (json.status === 1) {
      this.status.statusName = "enemyFound";
    } else if (json.status === 3) {
      this.status.statusName = "noEnemyFound";
    }
    this.callback(this.status);
  }
  _checkBattleTrxStatus() {

  }
  static generatePassword(length = 10) {
    var charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
      retVal = "";
    for (var i = 0, n = charset.length; i < length; ++i) {
      retVal += charset.charAt(Math.floor(Math.random() * n));
    }
    return retVal;
  }
}
async function getSMJson(url) {
  const res = await (fetch("https://api.steemmonsters.io" + url));
  const text = await res.text();
  try {
    return JSON.parse(text);
  } catch (e) {
    console.log("Invalid JSON; retrying", text)
    await new Promise((resolve) => setTimeout(resolve, 1000));
    return await getSMJson();
  }
}

async function checkQuest(){
const quest = await (fetch("https://api.steemmonsters.io/players/quests?username="+KEYS.dolochanusername));
const questAns = await quest.json()
var questAnss = questAns[0]
console.log(questAnss["name"])
console.log("Wins in Splinter: ")
console.log(questAnss["completed_items"])
if (questAnss["completed_items"] > 4 && questAnss["claim_date"]=== null){
  console.log('Rewards are ready to be collected on account "'+KEYS.dolochanusername+'"!')
  claimQuest(questAnss["id"]);
    }
    var g = new Date();
    g = g.getUTCDate();
    var diff = g-questAnss["created_date"]
if (diff.hours>=1 && diff.day>=1 && diff.minutes>=1&&questAnss["claim_date"] !== null){
startQuest()
}
if(questAnss["refresh_trx_id"]===null&&questAnss["name"]==="Pirate Attacks"||questAnss["name"]==="Lyanna's Call"){
refreshQuest(questAnss["id"])
}


  }

function refreshQuest(questID){
  steem.broadcast.customJson(KEYS.dolochanposting, [], [KEYS.dolochanusername], "sm_refresh_quest", JSON.stringify({
    "type": "daily",
    "app":"smitopbot-public/1.0.0"
}));

}

function startQuest(){
  steem.broadcast.customJson(KEYS.dolochanposting, [], [KEYS.dolochanusername], "sm_start_quest", JSON.stringify({
    "type": "daily",
    "app":"smitopbot-public/1.0.0"
}));
}

function claimQuest(questID){
    steem.broadcast.customJson(KEYS.dolochanposting, [], [KEYS.dolochanusername], "sm_claim_reward", JSON.stringify({
    "type": "quest",
    "quest_id":questID,
    "app":"smitopbot-public/1.0.0"
}));
    console.log("Quest Claimed!")

}

function checkStarter(cardid){
return cardData.filter(card => {
  if (cardid === card) {
    if(card.is_starter === true){
      return true
    }else {
      return false
    }
  }
});
}















async function checkRating(){
const rating = await (fetch("https://api.steemmonsters.io/players/quests?username="+KEYS.dolochanusername));
const ratingAns = await rating.json()
var ratingAnss = ratingAns[0]
console.log(ratingAnss["rating"])
}

async function checkBattle(txId, myVar){

const battlem = await fetch("https://api.steemmonsters.io/battle/status?id=" + txId);
const battlemm = await battlem.json()
var battlemmm = await battlemm

if(battlemmm["status"] === 1){
console.log("Battle is not over yet!")
battleover = false
return battleover
}else if(battlemmm["status"] === 2){

console.log("Battle is over!")

console.log("Playing another one...")
battleover = true
return battleover
}

}

function cardBcx(xp, rarity, edition, gold) {
  if (edition === 3) edition = 1; //reward cards are same as beta
  var cards = 0;
  if (edition == 0 && gold == 0 && rarity == 4)
    cards = (xp / 1000) + 1
  if (edition == 0 && gold == 0 && rarity == 3)
    cards = (xp / 250) + 1
  if (edition == 0 && gold == 0 && rarity == 2)
    cards = (xp / 100) + 1
  if (edition == 0 && gold == 0 && rarity == 1)
    cards = (xp / 20) + 1
  if (edition == 0 && gold == 1 && rarity == 4)
    cards = xp / 2500
  if (edition == 0 && gold == 1 && rarity == 3)
    cards = xp / 1000
  if (edition == 0 && gold == 1 && rarity == 2)
    cards = xp / 500
  if (edition == 0 && gold == 1 && rarity == 1)
    cards = xp / 250

  // Beta Edition Cards per XP
  if (edition == 1 && gold == 0 && rarity == 4)
    cards = (xp / 750) + 1
  if (edition == 1 && gold == 0 && rarity == 3)
    cards = (xp / 175) + 1
  if (edition == 1 && gold == 0 && rarity == 2)
    cards = (xp / 75) + 1
  if (edition == 1 && gold == 0 && rarity == 1)
    cards = (xp / 15) + 1
  if (edition == 1 && gold == 1 && rarity == 4)
    cards = xp / 2000
  if (edition == 1 && gold == 1 && rarity == 3)
    cards = xp / 800
  if (edition == 1 && gold == 1 && rarity == 2)
    cards = xp / 400
  if (edition == 1 && gold == 1 && rarity == 1)
    cards = xp / 200
  // Promo Edition Cards per XP
  if (edition == 2 && gold == 0 && rarity == 4)
    cards = (xp / 1000) + 1
  if (edition == 2 && gold == 0 && rarity == 3)
    cards = (xp / 250) + 1
  if (edition == 2 && gold == 0 && rarity == 2)
    cards = (xp / 100) + 1
  if (edition == 2 && gold == 0 && rarity == 1)
    cards = (xp / 20) + 1
  if (edition == 2 && gold == 1 && rarity == 4)
    cards = xp / 2500
  if (edition == 2 && gold == 1 && rarity == 3)
    cards = xp / 1000
  if (edition == 2 && gold == 1 && rarity == 2)
    cards = xp / 500
  if (edition == 2 && gold == 1 && rarity == 1)
    cards = xp / 250
  if (cards === 0) throw new Error("Unable to find card BCX");
  return cards
}

async function main() {
  let curBlock = -1;
  steem.api.streamBlockNumber((err, b) => curBlock = b);
  let ourCollection = (await getSMJson("/cards/collection/" + KEYS.dolochanusername)).cards;
  setInterval(async () => {
    ourCollection = (await getSMJson("/cards/collection/" + KEYS.dolochanusername)).cards;
    scanCollection();
  }, 1200000);

  function scanCollection() {
    ourCollection = ourCollection.filter(card => canPlayCard(card));
  }
  scanCollection();
  setInterval(() => scanCollection(), 25000);

  function bestCard(id) {
    return ourCollection.filter(card => (card.card_detail_id === id))
      .map(card => ({
        ...card,
        rarity: cardData.filter(cardData => card.card_detail_id === cardData.id)[0].rarity
      }))
      .sort((a, b) => {
        console.log(a, b);
        return cardBcx(a.xp, a.rarity, a.edition, a.gold) - cardBcx(b.xp, b.rarity, b.edition, b.gold)
      }).reverse()[0];
  }

  function printTeamNames(id){
    return ourCollection.filter(card => (card.id === id))
    console.log (card.name)

  }

  function canPlayCard(card) {
    if (card.market_id)
      return false;
    if (!card.last_transferred_block || !card.last_used_block)
      return true;
    if (card.delegated_to) return false;

    if (curBlock === -1) return true;
    var last_block = curBlock;
    return card.last_transferred_block <= last_block - 201600 || card.last_used_block <= last_block - 201600;
  }
  var submittedTeam = false;
  const battle = new Battle(async status => {
    console.log(status.statusName);
    if (!submittedTeam && (status.statusName === "enemyFound")) {
      var manaUsed = 3; //for summoner
      var colorSummoners = {
        Red: 5,
        Blue: 16,
        Green: 27,
        White: 38,
        Black: 49,
        Gold: 56,
        Daria: 88
      };
      function possibleCards(splinter, battle = {}) {
        return cardData.filter(card => {
          if (card.type !== "Monster") return;
          if ((card.color !== "Blue") && (card.color !== "Gray")) return;
          if (status.data.ruleset === "Lost Legendaries" && card.rarity === 4) return;
          if (status.data.ruleset === "Rise of the Commons" && card.rarity > 2) return;
          if (status.data.ruleset === "Taking Sides" && card.color === "Gray") return;
          //these should actually take in to account the level of the card. creeping ooze becomes a melee monster @ level 4, but this never allows it
          if (status.data.ruleset === "Up Close & Personal" && card.stats.attack[0] === 0) return;
          if (status.data.ruleset === "Broken Arrows" && card.stats.ranged[card.stats.ranged.length - 1] > 0) return;
          if (status.data.ruleset === "Little League" && (card.stats.mana[0] > 4)) return;
          return true;
        });

      };
function printCardName(id) {
        return cardData.filter(card => {
          if (card.id === id) {console.log(card.name)};

          return true;
        });

      };
      let team = [];
if(status.data.mana_cap=== 15){
var summoner = 49;
team = [50,46,51];
}
if(status.data.mana_cap=== 16){
var summoner = 49;
team = [50,46,51];
}
if(status.data.mana_cap=== 17){
var summoner = 49;
team = [50,46,51,52];
}
if(status.data.mana_cap=== 18){
var summoner = 49;
team = [50,46,51,52];
}
if(status.data.mana_cap=== 19){
var summoner = 5;
team = [7,64,3,62,4];
}
if(status.data.mana_cap=== 20){
var summoner = 5;
team = [8,1,3,62,6];
}
if(status.data.mana_cap=== 21){
var summoner = 38;
team = [40,34,39,65];
}
if(status.data.mana_cap=== 22){
var summoner = 5;
team = [64,8,3,62,1,6];
}
if(status.data.mana_cap=== 23){
var summoner = 49;
team = [50,52,51,46,65];
}
if(status.data.mana_cap=== 24){
var summoner = 49;
team = [50,52,51,46,65];
}
if(status.data.mana_cap=== 25){
var summoner = 38;
team = [40,34,39,66,65];
}
if(status.data.mana_cap=== 26){
var summoner = 49;
team = [50,52,51,46,66,65];
}
if(status.data.mana_cap=== 27){
var summoner = 38;
team = [40,34,39,66,35,65];
}
        var teamNames = []
        console.log("Ruleset: "+status.data.ruleset);
        console.log("Mana Cap: "+status.data.mana_cap);
        console.log("Summoner ID: "+summoner);
        console.log("Summoner Name: ");
        printCardName(summoner);
        console.log("Team IDs: "+team);
        console.log("Team Names: ")
        for (i = 0; i<team.length; i++){
          printCardName(team[i])
        }
        console.log("Inactive Splinters: "+status.data.inactive);
        battle.broadcastTeam("starter-"+summoner+"-Th0tti", team.map(card => {
          if(checkStarter === true){
          return "starter-"+card+"-BgOne"
        }else{
          return bestCard(card)
        }
        }));

        submittedTeam = true;

               battle.end();
      }
    });
}

main();