package ru.focusstart.levchugov.task3.model;


import com.fasterxml.jackson.core.type.TypeReference;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.jasypt.util.numeric.BasicIntegerNumberEncryptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.focusstart.levchugov.task3.settings.Setting;

import java.io.File;
import java.io.IOException;
import java.math.BigInteger;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class BestScoresStorage {
    private static final Logger logger = LoggerFactory.getLogger(BestScoresStorage.class);

    private static final String FILE_NAME = "High_Scores.json";
    private static final int DEFAULT_SCORE = 99999;

    private Map<String, Integer> scores;
    private Map<String, BigInteger> encryptedScores;

    private BasicIntegerNumberEncryptor numberEncryptor = new BasicIntegerNumberEncryptor();
    ObjectMapper objectMapper = new ObjectMapper();

    public BestScoresStorage() {
        numberEncryptor.setPassword("pass");
        scores = new HashMap<>();
        readScores();
    }

    private void readScores() {
        if (Files.exists(Paths.get(FILE_NAME))) {
            try {
                scores = objectMapper.readValue(new File(FILE_NAME),
                        new TypeReference<HashMap<String, Integer>>() {
                        });
                scores = decryptMap(scores);
                if (!isValidKeys()) {
                    resetScores();
                }
            } catch (IOException e) {
                logger.warn("Scores file reading problem", e);
                resetScores();
            }
        } else {
            resetScores();
        }
    }

    private void resetScores() {
        scores.clear();
        scores.put(Setting.EASY.getName(), DEFAULT_SCORE);
        scores.put(Setting.MIDDLE.getName(), DEFAULT_SCORE);
        scores.put(Setting.HARD.getName(), DEFAULT_SCORE);
    }

    public void writeScore() {
        try {
            scores = encryptMap(scores);
            objectMapper.writeValue(new File(FILE_NAME), scores);
        } catch (IOException e) {
            logger.error("Scores file writing problem");
        }
    }

    private boolean isValidKeys() {
        return scores.containsKey(Setting.EASY.getName()) && scores.containsKey(Setting.MIDDLE.getName()) && scores.containsKey(Setting.HARD.getName());
    }

    private Map<String, Integer> encryptMap(Map<String, Integer> map) {
        Map<String, Integer> encryptedMap = new HashMap<>();
        Set<String> keys = map.keySet();
        for (String key : keys) {
            encryptedMap.put(key, numberEncryptor.encrypt(BigInteger.valueOf(map.get(key))).intValue());
        }
        return encryptedMap;
    }

    private Map<String, Integer> decryptMap(Map<String, Integer> map) {
        Map<String, Integer> encryptedMap = new HashMap<>();
        Set<String> keys = map.keySet();
        for (String key : keys) {
            encryptedMap.put(key, numberEncryptor.encrypt(BigInteger.valueOf(map.get(key))).intValue());
        }
        return encryptedMap;
    }

   // private void лул() {
    //    BigInteger bigInteger = new BigInteger("2");
     //   bigInteger.intValue();
  //  }

    public int getScore(String difficulty) {
        return scores.get(difficulty);
    }

    public void setScore(String difficulty, int value) {
        scores.remove(difficulty);
        scores.put(difficulty, value);
        writeScore();
    }
}