/*
 * @author Javier Martin Manzano
 */

package ub.incendishab;

import android.os.Build;
import android.os.Environment;
import android.support.annotation.RequiresApi;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class DataManager {

    private JSONObject obj;

    private String direccion;
    private int escaleras, plantas, vivPorPlanta, ascensores, sotanos;
    private int formato;
    private boolean entresuelo, bajos, atico;

    private int evacuados,hospitalizados,confinados;
    private int revisados, noRevisados;
    private int afectEstructurales, afectHumo, afectFuego, afectOrigen;

    private int alturaTotal;
    private int longitudTotal;

    private String tempType;
    private JSONObject tempPers;

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public  DataManager(String direccion){
        this.direccion = direccion;
        readBuildingData();
    }

    @RequiresApi(Build.VERSION_CODES.KITKAT)
    public DataManager(Boolean loadPeople , String direccion, int escaleras, int plantas, int vivPorPlanta, int ascensores, int formato, boolean entresuelo, boolean bajos, boolean atico, int sotanos){
        this.direccion = direccion;
        this.escaleras = escaleras;
        this.plantas = plantas;
        this.vivPorPlanta = vivPorPlanta;
        this.ascensores = ascensores;
        this.formato = formato;
        this.entresuelo = entresuelo;
        this.bajos = bajos;
        this.atico = atico;
        this.sotanos = sotanos;
        this.evacuados = 0;
        this.hospitalizados = 0;
        this.confinados = 0;
        this.afectEstructurales = 0;
        this.afectHumo = 0;
        this.afectFuego = 0;
        this.afectOrigen = 0;
        this.revisados = 0;
        this.noRevisados = 0;

        if (loadPeople){
            loadData();
            evacuados = 0;
            hospitalizados = 0;
            confinados = 0;
            revisados = 0;
            noRevisados = 0;
            afectEstructurales = Integer.parseInt(obj.get("afectEstructurales").toString());
            afectHumo = Integer.parseInt(obj.get("afectHumo").toString());
            afectFuego = Integer.parseInt(obj.get("afectFuego").toString());
            afectOrigen = Integer.parseInt(obj.get("afectOrigen").toString());
            boolean dosEsc = false;
            JSONArray edificioPrev;
            JSONArray escaleraAPrev;
            JSONArray escaleraBPrev = null;
            JSONArray edif;

            //Si habia y sigue habiendo escalera unica -> copiar todas las personas a la misma posicion
            if ((Integer.parseInt(obj.get("escaleras afectadas").toString()))==1 && escaleras == 1){
                edificioPrev = (JSONArray) obj.get("edificio");
                edif = edificioPrev;
            }
            //Si habia y sigue habiendo dos escaleras -> copiar todas las personas a la misma posicion en ambas escaleras
            else if ((Integer.parseInt(obj.get("escaleras afectadas").toString()))==2 && escaleras == 2){
                escaleraAPrev = (JSONArray) obj.get("escaleraA");
                escaleraBPrev = (JSONArray) obj.get("escaleraB");
                edif = escaleraAPrev;
                dosEsc = true;
            }
            //Si habia escalera unica y ahora hay dos escaleras -> copiar todas las personas a la misma posicion de la escalera A
            else if ((Integer.parseInt(obj.get("escaleras afectadas").toString()))==1 && escaleras == 2){
                edificioPrev = (JSONArray) obj.get("edificio");
                edif = edificioPrev;
            }
            //Si habia dos escaleras y ahora hay escalera unica -> copiar todas las personas de la escalera A a la misma posicion
            else{
                escaleraAPrev = (JSONArray) obj.get("escaleraA");
                edif = escaleraAPrev;
            }
            writeBuildingData();
            for (int a = 0; a < alturaTotal; a++) {
                for (int l = 0; l < longitudTotal; l++) {
                    try {
                        JSONObject pisoPrev = (JSONObject) edif.get(a * longitudTotal + l);
                        if (Boolean.parseBoolean(pisoPrev.get("revisado").toString())){
                            setInspected(a,l,1,true);
                        }
                        for (int type = 0; type < 4; type++) {
                            //tempType = typeString(type);
                            JSONArray array;
                            //confinados
                            JSONArray prevConf = (JSONArray)((JSONArray)pisoPrev.get("confinados")).get(type);
                            JSONArray prevEvac = (JSONArray)((JSONArray)pisoPrev.get("evacuados")).get(type);
                            JSONArray prevHosp = (JSONArray)((JSONArray)pisoPrev.get("hospitalizados")).get(type);

                            if (escaleras==1) {
                                array = (JSONArray) obj.get("edificio");
                            } else {
                                array = (JSONArray) obj.get("escaleraA");
                            }
                            JSONObject obj = (JSONObject)array.get(a*longitudTotal + l);
                            JSONArray confinadosArray = (JSONArray) obj.get("confinados");
                            JSONArray evacuadosArray = (JSONArray) obj.get("evacuados");
                            JSONArray hospitalizadosArray = (JSONArray) obj.get("hospitalizados");

                            confinadosArray.remove(type);
                            confinadosArray.add(type,prevConf);

                            evacuadosArray.remove(type);
                            evacuadosArray.add(type,prevEvac);

                            hospitalizadosArray.remove(type);
                            hospitalizadosArray.add(type,prevHosp);
                            confinados += prevConf.size();
                            evacuados += prevEvac.size();
                            hospitalizados += prevHosp.size();

                        }
                    } catch (IndexOutOfBoundsException ex){

                    }
                }
            }
            if (dosEsc){
                edif = escaleraBPrev;
                for (int a = 0; a < alturaTotal; a++) {
                    for (int l = 0; l < longitudTotal; l++) {
                        JSONObject pisoPrev = (JSONObject)edif.get(a*longitudTotal + l);
                        if (Boolean.parseBoolean(pisoPrev.get("revisado").toString())){
                            setInspected(a,l,2,true);
                        }
                        for (int type = 0; type < 4; type++) {
                            //tempType = typeString(type);
                            JSONArray array = (JSONArray) obj.get("escaleraB");
                            //confinados
                            JSONArray prevConf = (JSONArray)((JSONArray)pisoPrev.get("confinados")).get(type);
                            JSONArray prevEvac = (JSONArray)((JSONArray)pisoPrev.get("evacuados")).get(type);
                            JSONArray prevHosp = (JSONArray)((JSONArray)pisoPrev.get("hospitalizados")).get(type);

                            JSONObject obj = (JSONObject)array.get(a*longitudTotal + l);
                            JSONArray confinadosArray = (JSONArray) obj.get("confinados");
                            JSONArray evacuadosArray = (JSONArray) obj.get("evacuados");
                            JSONArray hospitalizadosArray = (JSONArray) obj.get("hospitalizados");

                            confinadosArray.remove(type);
                            confinadosArray.add(type,prevConf);

                            evacuadosArray.remove(type);
                            evacuadosArray.add(type,prevEvac);

                            hospitalizadosArray.remove(type);
                            hospitalizadosArray.add(type,prevHosp);
                            confinados += prevConf.size();
                            evacuados += prevEvac.size();
                            hospitalizados += prevHosp.size();

                            //tempType = typeString(type);
                            //confinados
                            /*JSONArray confinadosArray = (JSONArray)piso.get("confinados");
                            tempPersArray = (JSONArray)confinadosArray.remove(type);
                            confinadosArray.add(type,new JSONArray());
                            addConfPerson(a,l,2);*/
                            //evacuados
                            /*JSONArray evacuadosArray = (JSONArray)piso.get("evacuados");
                            tempPersArray = (JSONArray)evacuadosArray.remove(type);
                            evacuadosArray.add(type,new JSONArray());
                            addEvacPerson(a,l,2);*/
                            //hospitalizados
                            /*JSONArray hospitalizadosArray = (JSONArray)piso.get("hospitalizados");
                            tempPersArray = (JSONArray)hospitalizadosArray.remove(type);
                            hospitalizadosArray.add(type,new JSONArray());
                            addHospPerson(a,l,2);*/
                        }
                    }
                }
            }
            saveData();
        } else {
            writeBuildingData();
        }
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    private void writeBuildingData(){

        obj = new JSONObject();
        //Misc info
        obj.put("direccion",direccion);
        obj.put("escaleras afectadas",escaleras);
        obj.put("plantas",plantas);
        obj.put("puertas por planta",vivPorPlanta);
        obj.put("ascensores",ascensores);
        obj.put("formato",formato);
        obj.put("entresuelo",entresuelo);
        obj.put("bajos",bajos);
        obj.put("atico",atico);
        obj.put("sotanos",sotanos);
        obj.put("evacuados",evacuados);
        obj.put("hospitalizados",hospitalizados);
        obj.put("confinados",confinados);
        obj.put("afectEstructurales",afectEstructurales);
        obj.put("afectHumo",afectHumo);
        obj.put("afectFuego",afectFuego);
        obj.put("afectOrigen",afectOrigen);

        //Escalera + ascensores + zona piso + pisos
        longitudTotal = 2 + ascensores + vivPorPlanta;
        //plantas + bajo + tejado
        alturaTotal = plantas+2+sotanos;
        if (atico){
            alturaTotal +=1;
        }
        if (entresuelo){
            alturaTotal +=1;
        }
        if (escaleras==1){
            JSONArray edificio = new JSONArray();

            for (int p=0;p<alturaTotal;p++) {
                //Tejado
                if (p == 0) {
                    writeRoof(edificio, p);
                } else if (p >= alturaTotal-sotanos) {
                    //Sotanos
                    writeBasement(edificio, p);
                } else {
                    //Atico,pisos,bajo,entresuelo
                    writeFloors(edificio, p);
                }
            }
            obj.put("edificio",edificio);
        } else {
            JSONArray escaleraA = new JSONArray();
            JSONArray escaleraB = new JSONArray();

            for (int p=0;p<alturaTotal;p++) {
                //Tejado
                if (p == 0) {
                    writeRoof(escaleraA, p);
                    writeRoof(escaleraB, p);
                } else if (p >= alturaTotal-sotanos) {
                    //Sotanos
                    writeBasement(escaleraA, p);
                    writeBasement(escaleraB, p);
                } else {
                    //Atico,pisos,bajo,entresuelo
                    writeFloors(escaleraA, p);
                    writeFloors(escaleraB, p);
                }
            }

            obj.put("escaleraA",escaleraA);
            obj.put("escaleraB",escaleraB);
        }
        obj.put("revisados",revisados);
        obj.put("noRevisados",noRevisados);
        saveData();
    }

    private void writeRoof(JSONArray edificio, int p) {
        int lon=0;
        //Escalera
        addObjToArray(edificio,"tejado1","",lon,p);
        lon+=1;
        //Ascensores
        for (int a = 0; a < ascensores; a++) {
            addObjToArray(edificio,"tejado3","",lon,p);
            lon+=1;
        }
        //Area de piso
        addObjToArray(edificio,"tejado3","Tejado",lon,p);
        lon+=1;
        //Pisos
        for (int v = 0; v < vivPorPlanta; v++) {
            if (v!=vivPorPlanta-1) {
                addObjToArray(edificio,"tejado3","",lon,p);
            } else {
                addObjToArray(edificio,"tejado2","",lon,p);
            }
            lon+=1;
        }
    }

    private void writeFloors(JSONArray edificio, int p) {
        int lon=0;

        //Dibujar escalera
        addObjToArray(edificio,"escalera","",lon,p);
        lon+=1;

        //Dibujar ascensores y area de piso
        if (p == alturaTotal-1-sotanos) {
            for (int a = 0; a < ascensores; a++) {
                addObjToArray(edificio,"ascensor2","",lon,p);
                lon+=1;
            }
            addObjToArray(edificio,"bajo","Bajo",lon,p);
        } else {
            for (int a = 0; a < ascensores; a++) {
                addObjToArray(edificio,"ascensor1","",lon,p);
                lon+=1;
            }
            if (entresuelo && p == alturaTotal-2-sotanos) {
                addObjToArray(edificio,"bajo","Entresuelo",lon,p);
            } else if (atico && p==1) {
                addObjToArray(edificio,"bajo","Ático",lon,p);
            } else {
                int planta = alturaTotal-p-1-sotanos;
                if (entresuelo)
                    planta-=1;
                addObjToArray(edificio,"bajo",planta+"º",lon,p);
            }

        }
        lon+=1;

        //Dibujar pisos
        for (int v = 0; v < vivPorPlanta; v++) {
            String texto = getFormatString(v + 1);
            if (p == alturaTotal-1-sotanos) {
                if (bajos) {
                    addObjToArray(edificio, "piso", "Bajo " + texto, lon, p);
                } else {
                    addObjToArray(edificio, "bajo", "Bajo " + texto, lon, p);
                }
            } else if (entresuelo && p == alturaTotal-2-sotanos) {
                addObjToArray(edificio, "piso", "Entresuelo " + texto, lon, p);
            } else if (atico && p==1) {
                addObjToArray(edificio,"piso","Ático "+texto, lon,p);
            } else {
                int puerta = alturaTotal-p-1-sotanos;
                if (entresuelo)
                    puerta-=1;
                addObjToArray(edificio,"piso",puerta+"º "+texto,lon,p);
            }
            lon+=1;
        }
    }

    private void writeBasement(JSONArray edificio, int p) {
        int lon=0;
        //Escalera
        addObjToArray(edificio,"escalera","",lon,p);
        lon+=1;
        //Ascensores
        for (int a = 0; a < ascensores; a++) {
            addObjToArray(edificio,"ascensor1","",lon,p);
            lon+=1;
        }
        //Area de piso
        addObjToArray(edificio,"bajo","Sótano "+(sotanos-(alturaTotal-p)+1),lon,p);
        lon+=1;
        //Pisos
        for (int v = 0; v < vivPorPlanta; v++) {
            addObjToArray(edificio,"bajo","",lon,p);
            lon+=1;
        }
    }

    private void addObjToArray(JSONArray array, String imagen,String texto, int lon, int p){
        JSONObject obj2 = new JSONObject();
        obj2.put("altura",p);
        obj2.put("longitud",lon);
        obj2.put("imagen",imagen);
        createPersonTypesArrays(obj2, "confinados");
        createPersonTypesArrays(obj2, "evacuados");
        createPersonTypesArrays(obj2, "hospitalizados");
        obj2.put("estado","normal");
        obj2.put("observaciones","");
        obj2.put("texto",texto);
        obj2.put("revisado", false);
        array.add(obj2);
        noRevisados++;
    }

    private void createPersonTypesArrays(JSONObject obj2, String arrayName){
        JSONArray array = new JSONArray();
        JSONArray ok = new JSONArray();
        JSONArray z4 = new JSONArray();
        JSONArray z5 = new JSONArray();
        JSONArray z6 = new JSONArray();
        array.add(ok);
        array.add(z4);
        array.add(z5);
        array.add(z6);
        obj2.put(arrayName ,array);
    }

    private String getFormatString(int i){
        if (formato==1) {
            return Integer.toString(i)+"ª";
        } else if (formato==2){
            return ((char)(i+64))+"";
        }
        return "";
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    private void readBuildingData(){
        loadData();
        escaleras = Integer.parseInt(obj.get("escaleras afectadas").toString());
        plantas = Integer.parseInt(obj.get("plantas").toString());
        vivPorPlanta = Integer.parseInt(obj.get("puertas por planta").toString());
        ascensores = Integer.parseInt(obj.get("ascensores").toString());
        formato = Integer.parseInt(obj.get("formato").toString());
        entresuelo = (boolean)obj.get("entresuelo");
        bajos = (boolean)obj.get("bajos");
        atico = (boolean)obj.get("atico");
        sotanos = Integer.parseInt(obj.get("sotanos").toString());
        evacuados = Integer.parseInt(obj.get("evacuados").toString());
        hospitalizados = Integer.parseInt(obj.get("hospitalizados").toString());
        confinados = Integer.parseInt(obj.get("confinados").toString());
        revisados = Integer.parseInt(obj.get("revisados").toString());;
        noRevisados = Integer.parseInt(obj.get("noRevisados").toString());;
        afectEstructurales = Integer.parseInt(obj.get("afectEstructurales").toString());
        afectHumo = Integer.parseInt(obj.get("afectHumo").toString());
        afectFuego = Integer.parseInt(obj.get("afectFuego").toString());
        afectOrigen = Integer.parseInt(obj.get("afectOrigen").toString());

        longitudTotal = 2 + ascensores + vivPorPlanta;
        alturaTotal = plantas+2+sotanos;
        if (atico){
            alturaTotal +=1;
        }
        if (entresuelo){
            alturaTotal +=1;
        }
    }

    public ArrayList<Object> returnData(){

        ArrayList<Object> a = new ArrayList();
        a.add(plantas);
        a.add(vivPorPlanta);
        a.add(direccion);
        a.add(escaleras);
        a.add(ascensores);
        a.add(formato);
        a.add(entresuelo);
        a.add(bajos);
        a.add(atico);
        a.add(sotanos);
        return a;
    }

    public String readImage(int height, int width, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        int i = getIndexByHeightAndLength(height,width,array);
        return ((JSONObject)array.get(i)).get("imagen").toString();
    }

    public boolean readInspected(int height, int width, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        int i = getIndexByHeightAndLength(height,width,array);
        return Boolean.parseBoolean(((JSONObject)array.get(i)).get("revisado").toString());
    }

    public String readState(int height, int width, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        int i = getIndexByHeightAndLength(height,width,array);
        return ((JSONObject)array.get(i)).get("estado").toString();
    }

    public String readText(int height, int width, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        int i = getIndexByHeightAndLength(height,width,array);
        return ((JSONObject)array.get(i)).get("texto").toString();
    }

    public String readObservations(int height, int width, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        int i = getIndexByHeightAndLength(height,width,array);
        return ((JSONObject)array.get(i)).get("observaciones").toString();
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public void setObservations(int height, int width, String obs, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        int i = getIndexByHeightAndLength(height,width,array);
        ((JSONObject)array.get(i)).put("observaciones", obs);
        saveData();
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public void setInspected(int height, int width, int escalera, boolean rev) {
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        int i = getIndexByHeightAndLength(height,width,array);
        ((JSONObject)array.get(i)).put("revisado", rev);
        if (rev){
            revisados++;
            noRevisados--;
        } else {
            revisados--;
            noRevisados++;
        }
        saveData();
    }


    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public void setState(int height, int width, String estado, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        int i = getIndexByHeightAndLength(height,width,array);
        String prevEstado = ((JSONObject)array.get(i)).get("estado").toString();
        if (prevEstado.contains("estructural") && !estado.contains("estructural")){
            afectEstructurales--;
        } else if (!prevEstado.contains("estructural") && estado.contains("estructural")){
            afectEstructurales++;
        }
        if (prevEstado.contains("humo") && !estado.contains("humo")){
            afectHumo--;
        } else if (!prevEstado.contains("humo") && estado.contains("humo")){
            afectHumo++;
        }
        if (prevEstado.contains("afectado") && !estado.contains("afectado")){
            afectFuego--;
        } else if (!prevEstado.contains("afectado") && estado.contains("afectado")){
            afectFuego++;
        }
        if (prevEstado.contains("origen") && !estado.contains("origen")){
            afectOrigen--;
        } else if (!prevEstado.contains("origen") && estado.contains("origen")){
            afectOrigen++;
        }
        ((JSONObject)array.get(i)).put("estado", estado);
        saveData();
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public void addConfPerson(int alt, int lon, String personType,int quant, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray confinadosArray = (JSONArray)obj.get("confinados");
        JSONObject obj2;

        JSONArray typeArray = (JSONArray)confinadosArray.get(typeIndex(personType));
        for (int i=0;i<quant;i++) {
            obj2 = new JSONObject();
            obj2.put("edad","desconocida");
            obj2.put("especial","desconocido");
            typeArray.add(obj2);
        }
        confinados += quant;
        saveData();
    }


    @RequiresApi(Build.VERSION_CODES.KITKAT)
    public void addEvacPerson(int alt, int lon, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray evacuadosArray = (JSONArray)obj.get("evacuados");

        JSONArray typeArray = (JSONArray)evacuadosArray.get(typeIndex(tempType));
        typeArray.add(tempPers);
        evacuados++;
        saveData();
    }

    @RequiresApi(Build.VERSION_CODES.KITKAT)
    public void addHospPerson(int alt, int lon, int escalera, String hosp){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray hospitalizadosArray = (JSONArray)obj.get("hospitalizados");
        JSONObject obj2;

        JSONArray typeArray = (JSONArray)hospitalizadosArray.get(typeIndex(tempType));
        obj2 = new JSONObject();
        obj2.put("edad",tempPers.get("edad"));
        obj2.put("especial",tempPers.get("especial"));
        obj2.put("hospital",hosp);
        typeArray.add(obj2);
        hospitalizados++;
        saveData();
    }

    @RequiresApi(Build.VERSION_CODES.KITKAT)
    public void addHospPerson(int alt, int lon, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray hospitalizadosArray = (JSONArray)obj.get("hospitalizados");

        JSONArray typeArray = (JSONArray)hospitalizadosArray.get(typeIndex(tempType));
        typeArray.add(tempPers);
        hospitalizados ++;
        saveData();
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public void addConfPerson(int alt, int lon, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray confinadosArray = (JSONArray)obj.get("confinados");

        JSONArray typeArray = (JSONArray)confinadosArray.get(typeIndex(tempType));
        typeArray.add(tempPers);
        confinados++;
        saveData();
    }

    private int typeIndex(String personType){
        int index;
        if (personType.contains("z4")) {
            index = 1;
        } else if (personType.contains("z5")) {
            index = 2;
        } else if (personType.contains("z6")) {
            index = 3;
        } else {
            index = 0;
        }
        return index;
    }

    private String typeString(int index){
        String type;
        if (index==1){
            type = "z4";
        } else if (index==2) {
            type = "z5";
        } else if (index==3) {
            type = "z6";
        } else {
            type = "ok";
        }
        return type;
    }

    public void removePerson(int alt, int lon, int escalera, String personType){
        tempType = personType;
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject piso = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray confinadosArray = (JSONArray)piso.get("confinados");
        tempPers = (JSONObject)((JSONArray)confinadosArray.get(typeIndex(personType))).remove(0);
        confinados -= 1;
    }

    public int confInApartment(int alt, int lon, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        return ((JSONArray)obj.get("confinados")).size();
    }

    public int evacInApartment(int alt, int lon, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        return ((JSONArray)obj.get("evacuados")).size();
    }

    public int hospInApartment(int alt, int lon, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        return ((JSONArray)obj.get("hospitalizados")).size();
    }

    public int readConfQuant(int alt, int lon, int i, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("confinados");
        return (((JSONArray)peopleArray.get(i)).size());
    }

    public int readEvacQuant(int alt, int lon, int i, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("evacuados");
        return (((JSONArray)peopleArray.get(i)).size());
    }

    public int readHospQuant(int alt, int lon, int i, int escalera){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("hospitalizados");
        return (((JSONArray)peopleArray.get(i)).size());
    }

    public String readConfAge(int alt, int lon, int escalera, int type, int elem){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("confinados");
        return ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).get("edad").toString();
    }

    public String readConfSpec(int alt, int lon, int escalera, int type, int elem){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("confinados");
        return ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).get("especial").toString();
    }

    public String readEvacAge(int alt, int lon, int escalera, int type, int elem){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("evacuados");
        return ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).get("edad").toString();
    }

    public String readEvacSpec(int alt, int lon, int escalera, int type, int elem){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("evacuados");
        return ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).get("especial").toString();
    }

    public String readHospAge(int alt, int lon, int escalera, int type, int elem){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("hospitalizados");
        return ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).get("edad").toString();
    }

    public String readHospSpec(int alt, int lon, int escalera, int type, int elem){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("hospitalizados");
        return ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).get("especial").toString();
    }

    public String readHospitalName(int alt, int lon, int escalera, int type, int elem){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("hospitalizados");
        return ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).get("hospital").toString();
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public void editHospital(int alt, int lon, int escalera, int type, int elem, String hosp){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("hospitalizados");
        ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).put("hospital", hosp);
        saveData();
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public void editConfAge(int alt, int lon, int escalera, int type, int elem, String newAge){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("confinados");
        ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).put("edad", newAge);
        saveData();
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public void editEvacAge(int alt, int lon, int escalera, int type, int elem, String newAge){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("evacuados");
        ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).put("edad", newAge);
        saveData();
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public void editHospAge(int alt, int lon, int escalera, int type, int elem, String newAge){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("hospitalizados");
        ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).put("edad", newAge);
        saveData();
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public void editConfSpec(int alt, int lon, int escalera, int type, int elem, String newSpec){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("confinados");
        ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).put("especial", newSpec);
        saveData();
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public void editEvacSpec(int alt, int lon, int escalera, int type, int elem, String newSpec){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("evacuados");
        ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).put("especial", newSpec);
        saveData();
    }

    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    public void editHospSpec(int alt, int lon, int escalera, int type, int elem, String newSpec){
        JSONArray array;
        if (escaleras==1) {
            array = (JSONArray) obj.get("edificio");
        } else {
            if (escalera == 1){
                array = (JSONArray) obj.get("escaleraA");
            } else { //escalera == 2
                array = (JSONArray) obj.get("escaleraB");
            }
        }
        JSONObject obj = (JSONObject)array.get(alt*longitudTotal + lon);
        JSONArray peopleArray = (JSONArray)obj.get("hospitalizados");
        ((JSONObject)(((JSONArray)peopleArray.get(type)).get(elem))).put("especial", newSpec);
        saveData();
    }

    private int getIndexByHeightAndLength(int alt, int lon, JSONArray array){
        int index = -1;
        for (int i=0;i<array.size();i++){
            if (((JSONObject)array.get(i)).get("altura").toString().equals(String.valueOf(alt)) &&
                ((JSONObject)array.get(i)).get("longitud").toString().equals(String.valueOf(lon)) ){
                return i;
            }
        }
        return index;
    }


    public int getConfinados() {
        return confinados;
    }

    public int getEvacuados() {
        return evacuados;
    }

    public int getHospitalizados() {
        return hospitalizados;
    }

    public int getAfectEstructurales() {
        return afectEstructurales;
    }

    public int getAfectHumo() {
        return afectHumo;
    }

    public int getAfectFuego() {
        return afectFuego;
    }

    public int getAfectOrigen() {
        return afectOrigen;
    }

    public int getRevisados() {
        return revisados;
    }

    public int getNoRevisados() {
        return noRevisados;
    }

    public int getAlturaTotal() {
        return alturaTotal;
    }

    public int getLongitudTotal() {
        return longitudTotal;
    }

    public int getEscaleras() {
        return escaleras;
    }

    @RequiresApi(Build.VERSION_CODES.KITKAT)
    private void saveData(){
        obj.put("confinados",confinados);
        obj.put("evacuados",evacuados);
        obj.put("hospitalizados",hospitalizados);
        obj.put("afectEstructurales",afectEstructurales);
        obj.put("afectHumo",afectHumo);
        obj.put("afectFuego",afectFuego);
        obj.put("afectOrigen",afectOrigen);
        obj.put("revisados",revisados);
        obj.put("noRevisados",noRevisados);
        try {
            new File(Environment.getExternalStorageDirectory().getPath()+"/inchab/").mkdir();
            FileWriter file = new FileWriter(Environment.getExternalStorageDirectory().getPath()+"/inchab/"+direccion+".json");
            file.write(this.obj.toJSONString());
            file.flush();
        } catch (IOException e){
            e.printStackTrace();
        }
    }

    private void loadData(){
        FileReader reader;
        try {
            reader = new FileReader(Environment.getExternalStorageDirectory().getPath()+"/inchab/"+direccion+".json");
            JSONParser parser = new JSONParser();
            obj = (JSONObject)parser.parse(reader);
        } catch (IOException e){
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
