using System;
using System.Collections;
using System.Security.Cryptography;
using System.Text;

public class StStorageLocal {

public static void put(string key, string value) {
PlayerPrefs.SetString(key, value);
PlayerPrefs.Save();
}

public static string get(string key) {
string value = PlayerPrefs.GetString(key);
if(!string.IsNullOrEmpty(value)) {
return value;
}
return value;
}

public static bool exist(string key)
{
return PlayerPrefs.HasKey(key);
}
}

using System.Collections;
using System.Collections.Generic;
using SimpleJSON;


public class StUserAchivements {

private static StUserAchivements mInstance;
private static readonly string keyStorage = "userachivements";
private int curWorld;
private List<List<int>> achievements;

public static int CurWorld
{
get
{
return Instance.curWorld;
}
set
{
Instance.curWorld = value;
Instance.saveLocalStorage();
}
}

public StUserAchivements()
{
curWorld = 0;
achievements = new List<List<int>>();
}

public static StUserAchivements Instance
{
get {
if(mInstance == null) {
mInstance = new StUserAchivements();
mInstance.load();
}
return mInstance;
}
}

public bool assignData(JSONNode jsonNode) {
//Check revision
if (!string.IsNullOrEmpty(jsonNode["curWorld"].Value))
{
curWorld = jsonNode["curWorld"].AsInt;
}
for (int i = 0; i < jsonNode["achievements"].Count; ++i)
{
List<int> list = new List<int>();
for (int j = 0; j < jsonNode["achievements"][i].Count; ++j)
{
list.Add(jsonNode["achievements"][i][j].AsInt);
}
achievements.Add(list);
}

return true;
}

public bool load() {
string data = StStorageLocal.get(keyStorage);
if(!string.IsNullOrEmpty(data)) {
var jsonNode = JSONNode.LoadFromBase64(data);
return assignData(jsonNode);
}
return false;
}

public bool update(string data) {
if(!string.IsNullOrEmpty(data)) {
var jsonNode = JSONNode.Parse(data);
if(assignData(jsonNode)) {
saveLocalStorage();
return true;
}
}
return false;
}

public string saveToBase64() {
var jsonObj = new JSONClass();

jsonObj["curWorld"].AsInt = curWorld;

for (int i = 0; i < achievements.Count; ++i)
{
for (int j = 0; j < achievements[i].Count; ++j)
{
jsonObj["achievements"][i][j].AsInt = (int)achievements[i][j];
}
}

return jsonObj.SaveToBase64();
}

public void saveLocalStorage() {
string data = saveToBase64();
StStorageLocal.put(keyStorage, data);
}

public static List<int> openNewWorld(int index, int numberMap)
{
if (!discoverWorld(index))
{
List<int> list = new List<int>(numberMap);
list.Add(0);
for (int i = 1; i < numberMap; ++i)
{
list.Add(-1);
}
Instance.achievements.Add(list);
Instance.saveLocalStorage();
return list;
}
return null;
}

public static bool isLockMap(int index)
{
if (discoverWorld(Instance.curWorld))
{
if (Instance.achievements[CurWorld][index] != -1)
{
return false;
}
}
return true;
}

public static bool setRankLevel(int index, int type)
{
if (discoverWorld(Instance.curWorld))
{
if (index < Instance.achievements[CurWorld].Count)
Instance.achievements[CurWorld][index] = type;
int nextIndex = index + 1;
if (nextIndex < Instance.achievements[CurWorld].Count)
{
if (Instance.achievements[CurWorld][nextIndex] == -1)
{
Instance.achievements[CurWorld][nextIndex] = 0;
}
}
else
{
Debug.Log("Complete map");
}

Instance.saveLocalStorage();
return true;
}
return false;
}
}