using UnityEngine;
using System.Collections;
using System.IO;
using MiniJSON;
using System.Collections.Generic;
using System.Linq;
using System;


public class LevelLoader : MonoBehaviour 
{
    public static LevelLoader instance = null;

    [Header("Basic")]
    public int level;
    public int column;
    public int row;
    public int moves;

    // layers
    [Header("Layers")]
    public List<TILE_TYPE> tileLayerData;
    public List<WAFFLE_TYPE> waffleLayerData;
    public List<ITEM_TYPE> itemLayerData;
    public List<CAGE_TYPE> cageLayerData;

    Dictionary<string, string> names = new Dictionary<string, string>();

    // properties
    [Header("Cookie")]
    public List<ITEM_TYPE> usingCookies;
    public List<int> usingColors;
    public List<int> cookieWeight;

    [Header("Gingerbread")]
    public List<ITEM_TYPE> usingGingerbreads;    
    public List<int> gingerbreadWeight;
    public List<int> gingerbreadMarkers;
    public int maxGingerbread;

    [Header("Target")]
    public TARGET_TYPE target1Type = TARGET_TYPE.NONE;
    public TARGET_TYPE target2Type = TARGET_TYPE.NONE;
    public TARGET_TYPE target3Type = TARGET_TYPE.NONE;
    public TARGET_TYPE target4Type = TARGET_TYPE.NONE;
    [Header("")]
    public int target1Amount;
    public int target2Amount;
    public int target3Amount;
    public int target4Amount;
    [Header("")]
    public int target1Color;
    public int target2Color;
    public int target3Color;
    public int target4Color;
    [Header("")]
    public int score1Star;
    public int score2Star;
    public int score3Star;
    [Header("")]
    public string targetText;

    [Header("Collectible")]
    public List<int> collectibleCollectColumnMarkers;
    public List<int> collectibleCollectNodeMarkers;
    public List<int> collectibleGenerateMarkers;
    public int collectibleMaxOnBoard;

    [Header("Marshmallow")]
    public int marshmallowMoreThanTarget;

    [Header("Cake")]
    public int cake;    

    void Awake()
    {
        if (instance == null)
        {
            instance = this;
        }
        else if (instance != null)
        {
            Destroy(gameObject);
        }

        DontDestroyOnLoad(gameObject);
    }

    public PuzzleLeveData currLevelData;
    public void LoadPuzzleGameData(){
        string levelDataPath = $"PuzzleLevelData/PuzzleLevelData{level}";
        currLevelData = Resources.Load<PuzzleLeveData>(levelDataPath);
        if (currLevelData == null )
        {
            Debug.LogError($"Cannot found level at {levelDataPath}");
        }
    }

    public void LoadLevel(bool debug = false)
    {
        LoadPuzzleGameData();
        TextAsset jsonString;

        if (debug == true)
        {
            level = 999;
        }

        jsonString = Resources.Load("Levels/" + level, typeof(TextAsset)) as TextAsset;

        if (jsonString == null)
        {
            print("Can not load level data");
            return;
        }

        Clear();

        //print(jsonString);

        var dict = Json.Deserialize(jsonString.text) as Dictionary<string, object>;

        //var str = Json.Serialize(dict);

        //Debug.Log("serialized: " + str);

        column = int.Parse(dict["width"].ToString());
        row = int.Parse(dict["height"].ToString());

        #region tilesets

        var tilesets = (List<object>)dict["tilesets"];

        var tiles = (Dictionary<string, object>)tilesets[0];

        var images = (Dictionary<string, object>)tiles["tiles"];

        foreach (KeyValuePair<string, object> entry in images)
        {
            // do something with entry.Value or entry.Key
            var value = (Dictionary<string, object>)entry.Value;

            var image = (string)value["image"];

            string[] tokens = image.Split(new[] { "/" }, StringSplitOptions.None);

            var full = tokens[tokens.Length - 1];

            string[] parts = full.Split(new[] { "." }, StringSplitOptions.None);

            var name = parts[0];

            //print(name);

            if (!names.ContainsKey(entry.Key))
            {
                names.Add(entry.Key, name);
            }
        }

        #endregion

        #region layers

        var layers = (List<object>)dict["layers"];
                
        foreach (object obj in layers)
        {
            var layer = (Dictionary<string, object>)obj;

            var data = (List<object>)layer["data"];
            //print(data);

            var name = (string)layer["name"];

            // tile
            if (name == "tile_layer")
            {
                foreach (object datum in data)
                {
                    var type = DataToTileType(int.Parse(datum.ToString()));
                    tileLayerData.Add(type);
                }
            }

            // waffle
            else if (name == "waffle_layer")
            {
                foreach (object datum in data)
                {
                    var type = DataToWaffleType(int.Parse(datum.ToString()));
                    waffleLayerData.Add(type);
                }
            }

            // item
            else if (name == "item_layer")
            {
                foreach (object datum in data)
                {
                    var type = DataToItemType(int.Parse(datum.ToString()));
                    itemLayerData.Add(type);
                }
            }

            // cage
            else if (name == "cage_layer")
            {
                foreach (object datum in data)
                {
                    var type = DataToCageType(int.Parse(datum.ToString()));
                    cageLayerData.Add(type);
                }
            }
        }

        #endregion

        #region properties
        
        var properties = (Dictionary<string, object>)dict["properties"];

        // REQUIRED
        var cookies = ((string)properties["cookies"]).Split(',').ToList();
        var weights = ((string)properties["cookies_weight"]).Split(',').ToList();
                
        var count = 0;

        foreach (object obj in cookies)
        {
            var cookie = int.Parse(obj.ToString());
            var weight = int.Parse(weights[count].ToString());

            count++;

            if (cookie == 1)
            {
                switch (count)
                {
                    case 1:
                        usingCookies.Add(ITEM_TYPE.COOKIE_1);
                        usingColors.Add(1);
                        break;
                    case 2:
                        usingCookies.Add(ITEM_TYPE.COOKIE_2);
                        usingColors.Add(2);
                        break;
                    case 3:
                        usingCookies.Add(ITEM_TYPE.COOKIE_3);
                        usingColors.Add(3);
                        break;
                    case 4:
                        usingCookies.Add(ITEM_TYPE.COOKIE_4);
                        usingColors.Add(4);
                        break;
                    case 5:
                        usingCookies.Add(ITEM_TYPE.COOKIE_5);
                        usingColors.Add(5);
                        break;
                    case 6:
                        usingCookies.Add(ITEM_TYPE.COOKIE_6);
                        usingColors.Add(6);
                        break;
                }

                cookieWeight.Add(weight);
            }
        }

        if (properties.ContainsKey("gingerbread"))
        {
            if ((string)properties["gingerbread"] != "" && (string)properties["gingerbread_weight"] != "")
            {
                var gingerbreads = ((string)properties["gingerbread"]).Split(',').ToList();
                var gWeights = ((string)properties["gingerbread_weight"]).Split(',').ToList();

                count = 0;

                foreach (object obj in gingerbreads)
                {
                    var gingerbread = int.Parse(obj.ToString());
                    var gWeight = int.Parse(gWeights[count].ToString());

                    count++;

                    if (gingerbread == 1)
                    {
                        switch (count)
                        {
                            case 1:
                                usingGingerbreads.Add(ITEM_TYPE.GINGERBREAD_1);
                                break;
                            case 2:
                                usingGingerbreads.Add(ITEM_TYPE.GINGERBREAD_2);
                                break;
                            case 3:
                                usingGingerbreads.Add(ITEM_TYPE.GINGERBREAD_3);
                                break;
                            case 4:
                                usingGingerbreads.Add(ITEM_TYPE.GINGERBREAD_4);
                                break;
                            case 5:
                                usingGingerbreads.Add(ITEM_TYPE.GINGERBREAD_5);
                                break;
                            case 6:
                                usingGingerbreads.Add(ITEM_TYPE.GINGERBREAD_6);
                                break;
                        }

                        gingerbreadWeight.Add(gWeight);

                    }
                }
            }
        }

        if (properties.ContainsKey("gingerbread_max_on_board"))
        {
            if (properties["gingerbread_max_on_board"].ToString() != "")
            {
                maxGingerbread = int.Parse(properties["gingerbread_max_on_board"].ToString());
            }
        }

        if (properties.ContainsKey("gingerbread_generate_marker"))
        {
            var markers = ((string)properties["gingerbread_generate_marker"]).Split(',').ToList();

            foreach (object obj in markers)
            {
                if (obj.ToString() != "")
                {
                    var marker = int.Parse(obj.ToString());

                    gingerbreadMarkers.Add(marker);
                }                
            }
        }
        
        // REQUIRED
        moves = int.Parse(properties["moves"].ToString());

        // REQUIRED
        var target1 = ((string)properties["target_1"]).Split(',').ToList();

        if (target1.Count >= 2)
        {
            target1Type = DataToTargetType(int.Parse(target1[0].ToString()));
            target1Amount = int.Parse(target1[1].ToString());

            if (target1.Count == 3) target1Color = int.Parse(target1[2].ToString());
        }

        var target2 = ((string)properties["target_2"]).Split(',').ToList();

        if (target2.Count >= 2)
        {
            target2Type = DataToTargetType(int.Parse(target2[0].ToString()));
            target2Amount = int.Parse(target2[1].ToString());

            if (target2.Count == 3) target2Color = int.Parse(target2[2].ToString());
        }

        var target3 = ((string)properties["target_3"]).Split(',').ToList();

        if (target3.Count >= 2)
        {
            target3Type = DataToTargetType(int.Parse(target3[0].ToString()));
            target3Amount = int.Parse(target3[1].ToString());

            if (target3.Count == 3) target3Color = int.Parse(target3[2].ToString());
        }

        var target4 = ((string)properties["target_4"]).Split(',').ToList();

        if (target4.Count >= 2)
        {
            target4Type = DataToTargetType(int.Parse(target4[0].ToString()));
            target4Amount = int.Parse(target4[1].ToString());

            if (target4.Count == 3) target4Color = int.Parse(target4[2].ToString());
        }

        // REQUIRED
        score1Star = int.Parse(properties["score_1_star"].ToString());
        score2Star = int.Parse(properties["score_2_star"].ToString());
        score3Star = int.Parse(properties["score_3_star"].ToString());

        // REQUIRED
        cake = int.Parse(properties["cake"].ToString());

        // REQUIRED
        targetText = properties["target_text"].ToString();

        if (properties.ContainsKey("collectible_collect_marker"))
        {
            // collectible collect marker NOT required
            var markers = ((string)properties["collectible_collect_marker"]).Split(',').ToList();

            foreach (object obj in markers)
            {
                if (obj.ToString() != "")
                {
                    var marker = int.Parse(obj.ToString());

                    collectibleCollectColumnMarkers.Add(marker);
                }
            }
        }

        if (properties.ContainsKey("collectible_collect_node_marker"))
        {
            // collectible collect node marker NOT required
            var nodeMarkers = ((string)properties["collectible_collect_node_marker"]).Split(',').ToList();

            foreach (object obj in nodeMarkers)
            {
                if (obj.ToString() != "")
                {
                    var marker = int.Parse(obj.ToString());

                    collectibleCollectNodeMarkers.Add(marker);
                }
            }
        }

        if (properties.ContainsKey("collectible_generate_marker"))
        {
            // collectible generate marker NOT required
            var markers = ((string)properties["collectible_generate_marker"]).Split(',').ToList();

            foreach (object obj in markers)
            {
                if (obj.ToString() != "")
                {
                    var marker = int.Parse(obj.ToString());

                    collectibleGenerateMarkers.Add(marker);
                }
            }
        }

        if (properties.ContainsKey("collectible_max_on_board"))
        {
            // collectible max on board NOT required
            if (properties["collectible_max_on_board"].ToString() != "")
            {
                collectibleMaxOnBoard = int.Parse(properties["collectible_max_on_board"].ToString());
            }            
        }

        if (properties.ContainsKey("marshmallow_more_than_target"))
        {
            // marshmallow more than target NOT required
            if (properties["marshmallow_more_than_target"].ToString() != "")
            {
                marshmallowMoreThanTarget = int.Parse(properties["marshmallow_more_than_target"].ToString());
            }
        }

        #endregion
    }

    void Clear()
    {
        tileLayerData.Clear();
        waffleLayerData.Clear();
        itemLayerData.Clear();
        cageLayerData.Clear();

        usingCookies.Clear();
        usingColors.Clear();
        cookieWeight.Clear();

        usingGingerbreads.Clear();
        gingerbreadWeight.Clear();
        gingerbreadMarkers.Clear();
        maxGingerbread = 0;

        target1Type = TARGET_TYPE.NONE;
        target2Type = TARGET_TYPE.NONE;
        target3Type = TARGET_TYPE.NONE;
        target4Type = TARGET_TYPE.NONE;

        target1Amount = 0;
        target2Amount = 0;
        target3Amount = 0;
        target4Amount = 0;

        target1Color = 0;
        target2Color = 0;
        target3Color = 0;
        target4Color = 0;

        collectibleCollectColumnMarkers.Clear();
        collectibleCollectNodeMarkers.Clear();
        collectibleGenerateMarkers.Clear();
        collectibleMaxOnBoard = 0;

        marshmallowMoreThanTarget = 0;
    }

    #region Type

    TILE_TYPE DataToTileType(int key)
    {
        if (key == 0) return TILE_TYPE.NONE;

        var data = names[(key - 1).ToString()];

        switch (data)
        {
            case "none_tile":
                return TILE_TYPE.NONE;
            case "pass_through_tile":
                return TILE_TYPE.PASS_THROUGH;
            case "light_tile":
                return TILE_TYPE.LIGHT_TILE;
            case "dark_tile":
                return TILE_TYPE.DARD_TILE;
        }

        return TILE_TYPE.NONE;
    }

    ITEM_TYPE DataToItemType(int key)
    {
        if (key == 0) return ITEM_TYPE.NONE;
        
        var data = names[(key - 1).ToString()];

        switch (data)
        {
            case "random_item":
                return ITEM_TYPE.COOKIE_RAMDOM;
            case "rainbow":
                return ITEM_TYPE.COOKIE_RAINBOW;

            case "blue":
                return ITEM_TYPE.COOKIE_1;
            case "blue_bomb_breaker":
                return ITEM_TYPE.COOKIE_1_BOMB_BREAKER;
            case "blue_column_breaker":
                return ITEM_TYPE.COOKIE_1_COLUMN_BREAKER;
            case "blue_row_breaker":
                return ITEM_TYPE.COOKIE_1_ROW_BREAKER;
            case "blue_x_breaker":
                return ITEM_TYPE.COOKIE_1_X_BREAKER;

            case "green":
                return ITEM_TYPE.COOKIE_2;
            case "green_bomb_breaker":
                return ITEM_TYPE.COOKIE_2_BOMB_BREAKER;
            case "green_column_breaker":
                return ITEM_TYPE.COOKIE_2_COLUMN_BREAKER;
            case "green_row_breaker":
                return ITEM_TYPE.COOKIE_2_ROW_BREAKER;
            case "green_x_breaker":
                return ITEM_TYPE.COOKIE_2_X_BREAKER;

            case "orange":
                return ITEM_TYPE.COOKIE_3;
            case "orange_bomb_breaker":
                return ITEM_TYPE.COOKIE_3_BOMB_BREAKER;
            case "orange_column_breaker":
                return ITEM_TYPE.COOKIE_3_COLUMN_BREAKER;
            case "orange_row_breaker":
                return ITEM_TYPE.COOKIE_3_ROW_BREAKER;
            case "orange_x_breaker":
                return ITEM_TYPE.COOKIE_3_X_BREAKER;

            case "purple":
                return ITEM_TYPE.COOKIE_4;
            case "purple_bomb_breaker":
                return ITEM_TYPE.COOKIE_4_BOMB_BREAKER;
            case "purple_column_breaker":
                return ITEM_TYPE.COOKIE_4_COLUMN_BREAKER;
            case "purple_row_breaker":
                return ITEM_TYPE.COOKIE_4_ROW_BREAKER;
            case "purple_x_breaker":
                return ITEM_TYPE.COOKIE_4_X_BREAKER;

            case "red":
                return ITEM_TYPE.COOKIE_5;
            case "red_bomb_breaker":
                return ITEM_TYPE.COOKIE_5_BOMB_BREAKER;
            case "red_column_breaker":
                return ITEM_TYPE.COOKIE_5_COLUMN_BREAKER;
            case "red_row_breaker":
                return ITEM_TYPE.COOKIE_5_ROW_BREAKER;
            case "red_x_breaker":
                return ITEM_TYPE.COOKIE_5_X_BREAKER;

            case "yellow":
                return ITEM_TYPE.COOKIE_6;
            case "yellow_bomb_breaker":
                return ITEM_TYPE.COOKIE_6_BOMB_BREAKER;
            case "yellow_column_breaker":
                return ITEM_TYPE.COOKIE_6_COLUMN_BREAKER;
            case "yellow_row_breaker":
                return ITEM_TYPE.COOKIE_6_ROW_BREAKER;
            case "yellow_x_breaker":
                return ITEM_TYPE.COOKIE_6_X_BREAKER;

            case "marshmallow":
                return ITEM_TYPE.MARSHMALLOW;

            case "generic_gingerbread":
                return ITEM_TYPE.GINGERBREAD_RANDOM;
            case "blue_gingerbread":
                return ITEM_TYPE.GINGERBREAD_1;
            case "green_gingerbread":
                return ITEM_TYPE.GINGERBREAD_2;
            case "orange_gingerbread":
                return ITEM_TYPE.GINGERBREAD_3;
            case "purple_gingerbread":
                return ITEM_TYPE.GINGERBREAD_4;
            case "red_gingerbread":
                return ITEM_TYPE.GINGERBREAD_5;
            case "yellow_gingerbread":
                return ITEM_TYPE.GINGERBREAD_6;

            case "chocolate_1":
                return ITEM_TYPE.CHOCOLATE_1_LAYER;
            case "chocolate_2":
                return ITEM_TYPE.CHOCOLATE_2_LAYER;
            case "chocolate_3":
                return ITEM_TYPE.CHOCOLATE_3_LAYER;
            case "chocolate_4":
                return ITEM_TYPE.CHOCOLATE_4_LAYER;
            case "chocolate_5":
                return ITEM_TYPE.CHOCOLATE_5_LAYER;
            case "chocolate_6":
                return ITEM_TYPE.CHOCOLATE_6_LAYER;

            case "generic_rock_candy":
                return ITEM_TYPE.ROCK_CANDY_RANDOM;
            case "blue_rock_candy":
                return ITEM_TYPE.ROCK_CANDY_1;
            case "green_rock_candy":
                return ITEM_TYPE.ROCK_CANDY_2;
            case "orange_rock_candy":
                return ITEM_TYPE.ROCK_CANDY_3;
            case "purple_rock_candy":
                return ITEM_TYPE.ROCK_CANDY_4;
            case "red_rock_candy":
                return ITEM_TYPE.ROCK_CANDY_5;
            case "yellow_rock_candy":
                return ITEM_TYPE.ROCK_CANDY_6;

            case "collectible_1":
                return ITEM_TYPE.COLLECTIBLE_1;
            case "collectible_2":
                return ITEM_TYPE.COLLECTIBLE_2;
            case "collectible_3":
                return ITEM_TYPE.COLLECTIBLE_3;
            case "collectible_4":
                return ITEM_TYPE.COLLECTIBLE_4;
            case "collectible_5":
                return ITEM_TYPE.COLLECTIBLE_5;
            case "collectible_6":
                return ITEM_TYPE.COLLECTIBLE_6;
            case "collectible_7":
                return ITEM_TYPE.COLLECTIBLE_7;
            case "collectible_8":
                return ITEM_TYPE.COLLECTIBLE_8;
            case "collectible_9":
                return ITEM_TYPE.COLLECTIBLE_9;
            case "collectible_10":
                return ITEM_TYPE.COLLECTIBLE_10;
            case "collectible_11":
                return ITEM_TYPE.COLLECTIBLE_11;
            case "collectible_12":
                return ITEM_TYPE.COLLECTIBLE_12;
            case "collectible_13":
                return ITEM_TYPE.COLLECTIBLE_13;
            case "collectible_14":
                return ITEM_TYPE.COLLECTIBLE_14;
            case "collectible_15":
                return ITEM_TYPE.COLLECTIBLE_15;
            case "collectible_16":
                return ITEM_TYPE.COLLECTIBLE_16;
            case "collectible_17":
                return ITEM_TYPE.COLLECTIBLE_17;
            case "collectible_18":
                return ITEM_TYPE.COLLECTIBLE_18;
            case "collectible_19":
                return ITEM_TYPE.COLLECTIBLE_19;
            case "collectible_20":
                return ITEM_TYPE.COLLECTIBLE_20;
        }

        return ITEM_TYPE.NONE;
    }

    WAFFLE_TYPE DataToWaffleType(int key)
    {
        if (key == 0) return WAFFLE_TYPE.NONE;

        var data = names[(key - 1).ToString()];

        switch (data)
        {
            case "waffle_1":
                return WAFFLE_TYPE.WAFFLE_1;
            case "waffle_2":
                return WAFFLE_TYPE.WAFFLE_2;
            case "waffle_3":
                return WAFFLE_TYPE.WAFFLE_3;
        }

        return WAFFLE_TYPE.NONE;
    }

    CAGE_TYPE DataToCageType(int key)
    {
        if (key == 0) return CAGE_TYPE.NONE;

        var data = names[(key - 1).ToString()];

        switch (data)
        {
            case "cage_1":
                return CAGE_TYPE.CAGE_1;
        }

        return CAGE_TYPE.NONE;
    }

    TARGET_TYPE DataToTargetType(int data)
    {
        switch (data)
        {
            case 1:
                return TARGET_TYPE.SCORE;
            case 2:
                return TARGET_TYPE.COOKIE;
            case 3:
                return TARGET_TYPE.MARSHMALLOW;
            case 4:
                return TARGET_TYPE.WAFFLE;
            case 5:
                return TARGET_TYPE.COLLECTIBLE;
            case 6:
                return TARGET_TYPE.COLUMN_ROW_BREAKER;
            case 7:
                return TARGET_TYPE.BOMB_BREAKER;
            case 8:
                return TARGET_TYPE.X_BREAKER;
            case 9:
                return TARGET_TYPE.CAGE;
            case 10:
                return TARGET_TYPE.RAINBOW;
            case 11:
                return TARGET_TYPE.GINGERBREAD;
            case 12:
                return TARGET_TYPE.CHOCOLATE;
            case 13:
                return TARGET_TYPE.ROCK_CANDY;
        }

        return TARGET_TYPE.NONE;
    }

    #endregion

    #region Utility

    // random with weighted
    public ITEM_TYPE RandomCookie()
    {
        List<int> weightList = new List<int>();
        int currWeight =0;
        for (int j = 0; j < cookieWeight.Count; j++)
        {
            currWeight+= cookieWeight[j];
            weightList.Add(currWeight);
        }
        var index = UnityEngine.Random.Range(0, weightList[weightList.Count-1]);
        for(int j = 0; j < weightList.Count; j++){
            if(index<weightList[j]){
                return usingCookies[j];
            }
        }
        return ITEM_TYPE.COOKIE_1;
    }

    public int RandomColor()
    {
        var type = RandomCookie();

        switch (type)
        {
            case ITEM_TYPE.COOKIE_1:
                return 1;
            case ITEM_TYPE.COOKIE_2:
                return 2;
            case ITEM_TYPE.COOKIE_3:
                return 3;
            case ITEM_TYPE.COOKIE_4:
                return 4;
            case ITEM_TYPE.COOKIE_5:
                return 5;
            case ITEM_TYPE.COOKIE_6:
                return 6;
            default:
                return 0;
        }
    }

    // with weighted
    public ITEM_TYPE RandomGingerbread()
    {
        var gingerbreads = new List<ITEM_TYPE>();

        for (int i = 0; i < usingGingerbreads.Count; i++)
        {
            var type = usingGingerbreads[i];

            for (int j = 0; j < gingerbreadWeight[i]; j++)
            {
                switch (type)
                {
                    case ITEM_TYPE.GINGERBREAD_1:
                        gingerbreads.Add(ITEM_TYPE.GINGERBREAD_1);
                        break;
                    case ITEM_TYPE.GINGERBREAD_2:
                        gingerbreads.Add(ITEM_TYPE.GINGERBREAD_2);
                        break;
                    case ITEM_TYPE.GINGERBREAD_3:
                        gingerbreads.Add(ITEM_TYPE.GINGERBREAD_3);
                        break;
                    case ITEM_TYPE.GINGERBREAD_4:
                        gingerbreads.Add(ITEM_TYPE.GINGERBREAD_4);
                        break;
                    case ITEM_TYPE.GINGERBREAD_5:
                        gingerbreads.Add(ITEM_TYPE.GINGERBREAD_5);
                        break;
                    case ITEM_TYPE.GINGERBREAD_6:
                        gingerbreads.Add(ITEM_TYPE.GINGERBREAD_6);
                        break;
                }
            }
        }

        var index = UnityEngine.Random.Range(0, gingerbreads.Count);

        return gingerbreads[index];
    }

    public static void OpenLevel(int level)
    {
        LevelLoader.instance.level = level;
        LevelLoader.instance.LoadLevel();
    }

    #endregion
}