package disconsented.anssrpg.config;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedHashMap;

import net.minecraft.block.Block;
import net.minecraft.item.Item;
import disconsented.anssrpg.data.SkillInfo;

public class ConfigurationHandler {
    public static ArrayList<SkillInfo> skillInfo = new ArrayList<SkillInfo>(); //Has to be static
    public static double experienceCurve = 1.6;
    public static boolean debugInfo = true;
    public static boolean printOutItem = false;
    public static boolean printOutBlock = false;
    public static boolean printOutEntity = false;
    static ArrayList names = new ArrayList();
    static ArrayList mainStore = new ArrayList();
    LinkedHashMap entityList = new LinkedHashMap();
    static File fileNameMain = new File("/config/ANSSRPG","main.cfg");
    static String line = null;

    final static String LEVEL_CURVE = "Level Curve";
    final static String DEBUG_INFO = "Debug info";
    final static String PRINT_OUT_BLOCK  = "printOutItem";
    final static String PRINT_OUT_ITEM = "printOutBlock";
    final static String PRINT_OUT_Entity  = "printOutEntity";

    private static void writeDefaultSkill(String name, byte type){
        File fileName = new File ("config/ANSSRPG", name.toLowerCase()+".cfg");
        try {
            // Assume default encoding.
            FileWriter fileWriter = new FileWriter(fileName);
            // Always wrap FileWriter in BufferedWriter.
            BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
            bufferedWriter.write("//Skill Name: "+name);
            bufferedWriter.newLine();
            bufferedWriter.write("//Skill Type: "+type);
            bufferedWriter.newLine();
            bufferedWriter.write("//the ; represents a new section");
            bufferedWriter.newLine();
            bufferedWriter.write("//Information must be structued like: (notice the lack of spaces after:)");
            bufferedWriter.newLine();
            bufferedWriter.write("//Entry name:tile.stone");
            bufferedWriter.newLine();
            bufferedWriter.write("//Entry experience:1");
            bufferedWriter.newLine();
            bufferedWriter.write("//Entry level requirement:0");
            bufferedWriter.newLine();
            bufferedWriter.write("Entry name:");
            bufferedWriter.newLine();
            bufferedWriter.write("Entry experience:");
            bufferedWriter.newLine();
            bufferedWriter.write("Entry level requirement:");
            // Note that write() does not automatically
            // append a newline character.

            // Always close files.
            bufferedWriter.close();
        }
        catch(IOException ex) {
            System.out.println("Error writing to file '"+ fileName + "'");
            // Or we could just do this:
            // ex.printStackTrace();
        }
    }
    private static void writeDefaultMain(){
        try {
            // Assume default encoding.
             if (!fileNameMain.exists())
             {
                 fileNameMain.createNewFile();
             }
            FileWriter fileWriter = new FileWriter(fileNameMain);

            // Always wrap FileWriter in BufferedWriter.
            BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
            bufferedWriter.write("//the ; represents a new section");
            bufferedWriter.newLine();
            bufferedWriter.write("// List of skillnames goes here (Make sure there is only one per line)");
            bufferedWriter.newLine();
            bufferedWriter.write("//And suffixed by -# where # is the skill type number");
            bufferedWriter.newLine();
            bufferedWriter.write("// 1 = Block Breaking");
            bufferedWriter.newLine();
            bufferedWriter.write("// 2 = Crafting");
            bufferedWriter.newLine();
            bufferedWriter.write("// 3 = Killing Entities");
            bufferedWriter.newLine();
            bufferedWriter.write("example skill name=1");
            bufferedWriter.newLine();
            bufferedWriter.write(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");
            bufferedWriter.newLine();
            bufferedWriter.write(DEBUG_INFO+":false");
            bufferedWriter.newLine();
            bufferedWriter.write(LEVEL_CURVE+"1.6");
            bufferedWriter.newLine();
            bufferedWriter.write("PrintOutItem:false");
            bufferedWriter.newLine();
            bufferedWriter.write("PrintOutBlock:false");
            bufferedWriter.newLine();
            bufferedWriter.write("PrintOutEntity:false");
            // Note that write() does not automatically
            // append a newline character.

            // Always close files.
            bufferedWriter.close();
        }
        catch(IOException ex) {
            System.out.println("Error writing to file '"+ fileNameMain + "'");
            // Or we could just do this:
             ex.printStackTrace();

        }
    }
    /**
     * Handles the configuration files
     */
    public static void loadAndSave(){
        ArrayList skillNames = new ArrayList();
        ArrayList<Integer> type = new ArrayList<Integer>();
        int stage = 0;

         try { // Main reader
                // FileReader reads text files in the default encoding.
                FileReader fileReader =
                    new FileReader(fileNameMain);

                // Always wrap FileReader in BufferedReader.
                BufferedReader bufferedReader =
                    new BufferedReader(fileReader);
/*ignore comment lines
 * get the skill names
 * substring them to seperate the names(between":" and "-" and the type (after "-"/ last char)
 * Get debug info
 *
 */
                while((line = bufferedReader.readLine()) != null) {
                    if (!line.startsWith("/")){ //All ANSSRPG config files should start with a comment
                        mainStore.add(line);
                    }
                }

                // Always close files.
                System.out.println(mainStore);
                bufferedReader.close();
            }
            catch(FileNotFoundException ex) {
                System.out.println(
                    "Unable to open file '" + fileNameMain + "'");
                ex.printStackTrace();
                    writeDefaultMain();
            }
            catch(IOException ex) {
                System.out.println(
                    "Error reading file '" + fileNameMain + "'");
            }
         for (int i = 0; i < mainStore.size(); i++){
             if (!mainStore.get(i).toString().startsWith("/")){
                 switch (stage){
                 case 0:
                     if (mainStore.get(i).toString().startsWith(";")){
                         stage++;
                     }
                     else
                     {
                         names.add(mainStore.get(i).toString().substring(0, mainStore.get(i).toString().indexOf("=")));//Adding the skill name
                         type.add(Integer.parseInt(mainStore.get(i).toString().substring(mainStore.get(i).toString().indexOf("=")+1)) );
                     }
                     break;
                 case 1:
                     debugInfo = Boolean.parseBoolean(mainStore.get(i).toString().substring(mainStore.get(i).toString().indexOf(":")+1));
                     stage++;
                     break;
                 case 2:
                 experienceCurve = Double.parseDouble(mainStore.get(i).toString().substring(mainStore.get(i).toString().indexOf(":")+1));
                     break;
                 case 3:
                     printOutItem = Boolean.parseBoolean(mainStore.get(i).toString().substring(mainStore.get(i).toString().indexOf(":")+1));
                     break;
                 case 4:
                     printOutBlock = Boolean.parseBoolean(mainStore.get(i).toString().substring(mainStore.get(i).toString().indexOf(":")+1));
                     break;
                 case 5:
                     printOutEntity = Boolean.parseBoolean(mainStore.get(i).toString().substring(mainStore.get(i).toString().indexOf(":")+1));
                     stage = 0;
                     break;
                 }
                 if (mainStore.get(i).toString().contains("=")){ //If it contains - aka a skill name

                 }
                 if (mainStore.get(i).toString().contains(":")){//If it contans : aka a setting
                     if (mainStore.get(i).toString().contains(DEBUG_INFO)){
                         debugInfo = Boolean.parseBoolean(mainStore.get(i).toString());
                     }
                     else if (mainStore.get(i).toString().contains(LEVEL_CURVE)){
                         experienceCurve = Double.parseDouble(mainStore.get(i).toString());
                     }
                 }
             }
         }
        for(int i = 0; i < names.size(); i++){ // For the skills
            ArrayList entryName = new ArrayList();
            ArrayList entryExperience = new ArrayList();
            ArrayList entryRequirement = new ArrayList();
            File fileName = new File ("config/ANSSRPG", names.get(i).toString().toLowerCase()+".cfg");
            int x = 0;
             try {
                    // FileReader reads text files in the default encoding.
                    FileReader fileReader =
                        new FileReader(fileName);

                    // Always wrap FileReader in BufferedReader.
                    BufferedReader bufferedReader =
                        new BufferedReader(fileReader);

                    while((line = bufferedReader.readLine()) != null) {
                            if (line.startsWith("/")){
                            }
                        else {
                            switch (x){
                            case 0:
                                if(type.get(i)== 1){
                                entryName.add((Item)Block.blockRegistry.getObject((line.substring(line.indexOf(":")+1))));
                                }
                                if(type.get(i)== 2){

                                }
                                if(type.get(i)== 3){

                                }
                                x++;
                                break;
                            case 1:
                                entryExperience.add(Integer.parseInt(line.substring(line.indexOf(":")+1)));
                                x++;
                                break;
                            case 2:
                                entryRequirement.add(Integer.parseInt(line.substring(line.indexOf(":")+1)));
                                x = 0;
                                break;
                            }

                        }
                    }

                    // Always close files.
                    bufferedReader.close();
                }
                catch(FileNotFoundException ex) {
                    System.out.println("Unable to open file '" + fileName + "'");
                    writeDefaultSkill((String) names.get(i), type.get(i).byteValue());
                    ex.printStackTrace();
                }
                catch(IOException ex) {
                    System.out.println(
                        "Error reading file '" + fileName + "'");
                }
             skillInfo.add(new SkillInfo(entryExperience, entryRequirement, names.get(i).toString(), entryName,  type.get(i).byteValue()));
            /* entryExperience.clear();
             entryRequirement.clear();
             entryName.clear(); */
             for (int a = 0; a <+ skillInfo.size(); a++){
                 System.out.println(skillInfo.get(a).name);
             }
             /**
              * Perk config:
              * Name:
              * Description:
              * Point cost:
              * List of requirements: "Skill Name"-#
              */


        }
    }
}