import { PrismaClient } from '@prisma/client'
import { writeFileSync } from 'fs'

const db = new PrismaClient()

const color_names = {
  "white": ["W"],
  "black": ["B"],
  "blue": ["U"],
  "green": ["G"],
  "red": ["R"],
  "colorless": [],
  "azorius": ["W","U"],
  "dimir": ["U","B"],
  "rakdos": ["B","R"],
  "gruul": ["R","G"],
  "selesnya": ["G","W"],
  "orzhov": ["W","B"],
  "izzet": ["U","R"],
  "golgari": ["B","G"],
  "boros": ["R","W"],
  "simic": ["G","U"],
  "esper": ["W","U","B"],
  "grixis": ["U","B","R"],
  "jund": ["B","R","G"],
  "naya": ["R","G","W"],
  "bant": ["G","W","U"],
  "abzan": ["W","B","G"],
  "jeskai": ["U","R","W"],
  "sultai": ["B","G","U"],
  "mardu": ["R","W","B"],
  "temur": ["G","U","R"],
  "yore-tiller": ["W","U","B","R"],
  "glint-eye": ["U","B","R","G"],
  "dune-brood": ["B","R","G","W"],
  "ink-treader": ["R","G","W","U"],
  "witch-maw": ["G","W","U","B"],
  "five-color": ["G","W","U","B","R"],
}

function getColorName(colorArray) {
  const colorArrayID = colorArray.sort().join(',')
  for (const colorName of Object.keys(color_names)) {
    if(colorArrayID === color_names[colorName].sort().join(',')){
      return(colorName)
    }
  }
  return ""
}

// I need to create
//
// Commanders
//    top all 
//    top by colors 
//
// bsets
//    Commanders
//
//
// Lands
//      lands.json
//      All jsons lands from colors
// Types

async function createJson() {
  console.log("Fetching data...")
  console.log(process.env.NODE_ENV)
  const bsets = await db.bset.findMany({
    relationLoadStrategy: "join",
    include: {
      sets: {
        include: {
          cards: {
            include: {
              decks: true,
              decks_as_commander: true,
            }
          }
        }
      },
      decks: {
        include: {
          commander: {
            include: {
              decks_as_commander: true
            }
          } 
        }
      }
    }
  })


  let bsets_list_export = [] 
  let all_cards = []
  const commanderData = {"top": []}
  for (const colorName of Object.keys(color_names)) {
    commanderData[colorName] = []
  }
  let bset_cards_data_export = {}

  bsets.forEach((bset) => {
    let icons = []
    let set_codes = []
    let bset_cards = []

    bset.sets.forEach((set) => {
      icons.push(set.icon_svg_uri)
      set_codes.push(set.code)
      let cards_temp = set.cards
      for(let i = 0; i < cards_temp.length; i++){
        cards_temp[i].bset_id = bset.id
      }
      bset_cards = [...bset_cards, ...cards_temp]
      all_cards = [...all_cards, ...cards_temp]
    })


    bsets_list_export.push({name: bset.name, sanitized_name: bset.sanitized_name, icons, set_codes})
    
    // BSETS CARDS STATS
    bset_cards_data_export[bset.sanitized_name] = {
      "commander": [],
      "creature": [],
      "land": [],
      "enchantment": [],
      "sorcery": [],
      "instant": [],
      "planeswalker": [],
      "artifact": [],
    }

    for (const card of bset_cards) {
      let card_object = {
        "name": card.name,
        "sanitized_name": card.sanitized_name,
        "normal_image": card.normal_image,
        "small_image": card.small_image,
        "type": card.type,
        "layout": card.layout,
        "price": card.price,
        "cardmarket_uri": card.cardmarket_uri,
        "nbr_decks": card.decks.length,
        "total_decks": bset.decks.filter((deck) => card.color_identity.every(color => deck.color_identity.includes(color))).length,
        "color_identity": card.color_identity,
      }

      card_object.percent_decks = (card_object.total_decks != 0) ? parseInt(10000 * (card_object.nbr_decks / card_object.total_decks)) / 100 : 0

      bset_cards_data_export[bset.sanitized_name][card.type].push(card_object)
      
      if(card.can_be_commander) {
        card_object.total_decks = bset.decks.length
        card_object.nbr_decks = card.decks_as_commander != undefined ? card.decks_as_commander.length : 0 
        card_object.percent_decks = (card_object.total_decks != 0) ? parseInt(10000 * (card_object.nbr_decks / card_object.total_decks)) / 100 : 0
        bset_cards_data_export[bset.sanitized_name]["commander"].push(card_object)

        const colorName = getColorName(card.color_identity)

        if(colorName != "") {
          commanderData[colorName].push(card_object)
          commanderData["top"].push(card_object)
        }
      }
    }
  })

  if(process.env.NODE_ENV == "production") {
    console.log('Production detected !')
    writeFileSync("/app/data/misc/bsets.json",JSON.stringify(bsets_list_export), 'utf8')
  } else {
    writeFileSync(import.meta.dirname + "/json/misc/bsets.json",JSON.stringify(bsets_list_export), 'utf8')
  }


  //for (const card of all_cards) {
  //}

  for (const index of Object.keys(commanderData)) {
    let JSONToWrite = commanderData[index].sort((a,b) => b.percent_decks - a.percent_decks)
    if(process.env.NODE_ENV == "production") {
      console.log('Production detected !')
      writeFileSync("/app/data/commander/" + index + ".json",JSON.stringify(JSONToWrite), 'utf8')
    } else {
      writeFileSync(import.meta.dirname + "/json/commander/" + index + ".json",JSON.stringify(JSONToWrite), 'utf8')
    }
  }

  for (const index of Object.keys(bset_cards_data_export)) {
    let JSONToWrite = bset_cards_data_export[index]
    for (const type of Object.keys(JSONToWrite)) {
      JSONToWrite[type] = JSONToWrite[type].sort((a,b) => b.percent_decks - a.percent_decks)
    }
    if(process.env.NODE_ENV == "production") {
      console.log('Production detected !')
      writeFileSync("/app/data/bset/" + index + ".json",JSON.stringify(JSONToWrite), 'utf8')
    } else {
      writeFileSync(import.meta.dirname + "/json/bset/" + index + ".json",JSON.stringify(JSONToWrite), 'utf8')
    }
  }
}

createJson()