Soulstorm-wiki-backend/src/main/kotlin/com/dowstats/service/postparsing/PostParsingService.kt

package com.dowstats.service.postparsing

import com.dowstats.configuration.StorageConfig
import com.dowstats.data.entities.*
import com.dowstats.data.entities.addon.BuildingAddon
import com.dowstats.data.entities.research.Research
import com.dowstats.data.repositories.*
import org.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Service
import java.awt.image.BufferedImage
import java.io.File
import java.nio.file.Path
import javax.imageio.ImageIO
import kotlin.io.path.exists


@Service
class PostParsingService @Autowired constructor(
    val researchRepository: ResearchRepository,
    val addonRepository: AddonRepository,
    val unitRepository: UnitRepository,
    val sergeantRepository: SergeantRepository,
    val buildingRepository: BuildingRepository,
    val weaponRepository: WeaponRepository,
) {

    val log = LoggerFactory.getLogger(PostParsingService::class.java)

    fun bindResearch(mod: Mod) {
        try {
            val modId = mod.id!!
            val researches = researchRepository.findAllByModId(modId)
            val addons = addonRepository.findAllByModId(modId)
            val units = unitRepository.findByModIdAndRace(modId, null)
            val sergeants = sergeantRepository.findAllByModId(modId)
            val buildings = buildingRepository.findByModIdAndRace(modId, null)
            val weapons = weaponRepository.findAllByModId(modId)

            bindResearchUnits(units, researches)
            bindResearchSergeants(sergeants, researches)
            bindResearchBuildings(buildings, researches)
            bindResearchWeapons(weapons, researches)

            bindAddonUnits(units, addons)
            bindAddonSergeants(sergeants, addons)
            bindAddonBuildings(buildings, addons)
            bindAddonWeapons(weapons, addons)

        } catch (e: Exception) {
            log.warn("Error occurred during bind researches", e)
        }

    }

    private fun bindResearchUnits(units: List<DowUnit>, researches: List<Research>) {

        val unitsWithBindings: List<DowUnit> = researches.flatMap { research ->
            research.researchModifiers.mapNotNull { modifier ->
                units.find {
                    it.filenameSquad?.replace(".rgd", "") == modifier.target ||
                            it.filenameUnit?.replace(".rgd", "") == modifier.target
                }
                    ?.let {
                        it.affectedResearches.add(research)
                        it
                    }
            }
        }
        unitRepository.saveAll(unitsWithBindings)
        log.info("Successfully bind researches to units")
    }

    private fun bindResearchSergeants(sergeants: List<Sergeant>, researches: List<Research>) {

        val sergeantsWithBindings: List<Sergeant> = researches.flatMap { research ->
            research.researchModifiers.mapNotNull { modifier ->
                sergeants.find { it.filename.replace(".rgd", "") == modifier.target }?.let {
                    it.affectedResearches.add(research)
                    it
                }
            }
        }
        sergeantRepository.saveAll(sergeantsWithBindings)
        log.info("Successfully bind researches to sergeants")
    }

    private fun bindResearchBuildings(buildings: List<Building>, researches: List<Research>) {

        val buildingsWithBindings: List<Building> = researches.flatMap { research ->
            research.researchModifiers.mapNotNull { modifier ->
                buildings.find { it.filename?.replace(".rgd", "") == modifier.target }?.let {
                    it.affectedResearches.add(research)
                    it
                }
            }
        }
        buildingRepository.saveAll(buildingsWithBindings)
        log.info("Successfully bind researches to buildings")
    }

    private fun bindResearchWeapons(weapons: List<Weapon>, researches: List<Research>) {

        val weaponsWithBindings: List<Weapon> = researches.flatMap { research ->
            research.researchModifiers.mapNotNull { modifier ->
                weapons.find { it.filename?.replace(".rgd", "") == modifier.target }?.let {
                    it.affectedResearches.add(research)
                    it
                }
            }
        }
        weaponRepository.saveAll(weaponsWithBindings)
        log.info("Successfully bind researches to weapons")
    }

    private fun bindAddonUnits(units: List<DowUnit>, addons: List<BuildingAddon>) {

        val unitsWithBindings: List<DowUnit> = addons.flatMap { addon ->
            addon.addonModifiers.mapNotNull { modifier ->
                units.find {
                    it.filenameSquad?.replace(".rgd", "") == modifier.target ||
                            it.filenameUnit?.replace(".rgd", "") == modifier.target
                }
                    ?.let {
                        it.affectedAddons.add(addon)
                        it
                    }
            }
        }
        unitRepository.saveAll(unitsWithBindings)
        log.info("Successfully bind addons to units")
    }

    private fun bindAddonSergeants(sergeants: List<Sergeant>, addons: List<BuildingAddon>) {

        val sergeantsWithBindings: List<Sergeant> = addons.flatMap { addon ->
            addon.addonModifiers.mapNotNull { modifier ->
                sergeants.find { it.filename.replace(".rgd", "") == modifier.target }?.let {
                    it.affectedAddons.add(addon)
                    it
                }
            }
        }
        sergeantRepository.saveAll(sergeantsWithBindings)
        log.info("Successfully bind addons to sergeants")
    }

    private fun bindAddonBuildings(buildings: List<Building>, addons: List<BuildingAddon>) {

        val buildingsWithBindings: List<Building> = addons.flatMap { addon ->
            addon.addonModifiers.mapNotNull { modifier ->
                buildings.find { it.filename?.replace(".rgd", "") == modifier.target }?.let {
                    it.affectedAddons.add(addon)
                    it
                }
            }
        }
        buildingRepository.saveAll(buildingsWithBindings)
        log.info("Successfully bind addons to buildings")
    }

    private fun bindAddonWeapons(weapons: List<Weapon>, addons: List<BuildingAddon>) {

        val weaponsWithBindings: List<Weapon> = addons.flatMap { addon ->
            addon.addonModifiers.mapNotNull { modifier ->
                weapons.find { it.filename?.replace(".rgd", "") == modifier.target }?.let {
                    it.affectedAddons.add(addon)
                    it
                }
            }
        }
        weaponRepository.saveAll(weaponsWithBindings)
        log.info("Successfully bind addons to weapons")
    }
}