#include "Access.h"
#include <LiquidCrystal.h>
#include <EEPROM.h>
#include <Time\Time.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
const int led = 6;

enum NavigationButtons
{
    CONFIRM = 10,
    BACKING = 11
};

enum Views
{
    LOGIN_VIEW = 0,
    PASSWORD_VIEW = 1,
    ERROR_VIEW = 2,
    USSER_VIEW = 3,
    CHANGE_PASSWORD_VIEW_LOGIN = 5,
    CHANGE_PASSWORD_VIEW_OLD_PASSWORD = 6,
    CHANGE_PASSWORD_VIEW_PASSWORD1 = 7,
    CHANGE_PASSWORD_VIEW_PASSWORD2 = 8,
    ADD_USER_LOGIN = 9,
    ADD_USER_PASSWORD = 10,
    ADD_USER_CONFIRM_PASSWORD = 11,

};

class User
{
private:
    short _password;
    short _login;
    short _oldPassword1;
    short _oldPassword2;
    bool _wasSet;
public:
    User()
    {
        _login = -1;
    }
    short GetLogin()
    {
        return _login;
    }
    short GetPassword()
    {
        return _password;
    }
    short GetOldPassword1()
    {
        return _oldPassword1;
    }
    short GetOldPassword2()
    {
        return _oldPassword2;
    }
    void SetLogin(short value)
    {
        _login = value;
        _wasSet = true;
    }
    void SetPassword(short value)
    {
        _oldPassword2 = _oldPassword1;
        _oldPassword1 = _password;
        _password = value;
    }

    bool IsEmpty()
    {
        return _login == -1;
    }

    bool IsSet()
    {
        return _wasSet;
    }
};

class SingleHistory
{
    short _id;

public:
    SingleHistory()
    {
        _id = -1;
    }

    short GetName()
    {
        return _id;
    }

    void SetValue(short id)
    {
        _id = id;
    }

    bool IsSet()
    {
        return _id != -1;
    }
};

class HistoryIterator
{
    SingleHistory* _history;
    short _count;
    short _currentindex;

public:
    HistoryIterator(short count, SingleHistory* history)
    {
        _count = count;
        _currentindex = 0;
        _history = history;
    }

    bool CanMoveNext()
    {
        return _currentindex < _count;
    }

    void MoveNext()
    {
        _currentindex++;
    }

    SingleHistory GetValue()
    {
        return _history[_currentindex];
    }

};

class History
{
public:
    SingleHistory _history[50];
    long count;
public:
    History()
    {
        EEPROM.get(sizeof(short), count);
        if (count == -1)
        {
            count = 0;
            EEPROM.put(sizeof(short), count);
        }
        int index = 0;
        for (int i = sizeof(short) + sizeof(long); i < 50 * sizeof(short); i=i+sizeof(short))
        {
            EEPROM.get(i, _history[index]);
            Serial.println(_history[index].GetName());
            index++;
        }
    }
    void Add(SingleHistory history)
    {
        _history[count] = history;
        EEPROM.put(sizeof(short)+sizeof(long) + (count%50)*sizeof(short), history);
        count++;
        EEPROM.put(sizeof(short), count);
    }
};

class EpromAccessService
{
private:
    User _cache;
    short index;
public:
    EpromAccessService()
    {
        User currentUser;
        EEPROM.get(sizeof(short) , currentUser);

        if (currentUser.GetLogin() != 123)
        {
            Serial.println("Serial 123");
            Serial.print("History");
            Serial.println(sizeof(History));
            index = sizeof(short) + sizeof(History);
            User user = User();
            user.SetLogin(123);
            user.SetPassword(321);
            AddUser(user);
        }
        else
        {
            EEPROM.get(0, index);
            Serial.println("Serial else");
        }
    }
    User GetCurrentUser()
    {
        return _cache;
    }

    void UpdateUser(User user)
    {
        Serial.println(user.GetPassword());
        _cache = user;
    }

    void AddUser(User user)
    {
        EEPROM.put(index, user);
        index = index + sizeof(User);
        EEPROM.write(0, index);
    }

    User GetUserById(short id)
    {
        if (_cache.GetLogin() == id)
        {
            return _cache;
        }

        int length = EEPROM.length();
        User currentUser;

        for (int i = sizeof(short) + sizeof(History); i<length; i = i + sizeof(User))
        {
            EEPROM.get(i, currentUser);
            Serial.print("Id=");
            Serial.println(currentUser.GetLogin());
            if (currentUser.GetLogin() == id)
            {
                _cache = currentUser;
                return currentUser;
            }
        }

        currentUser = User();
        currentUser.SetLogin(-1);
        return currentUser;
    }

};

class ValueWrapper
{
    short _values[5];
    int index;

public:
    ValueWrapper()
    {
        index = 0;
    }
    void AddValue(short value)
    {
        if (index <5)
        {
            _values[index] = value;
            index++;
        }
    }

    short GetValue()
    {
        short resultValue = 0;
        for (int i = 0; i<index; i++)
        {
            if (i<index - 1)
            {
                resultValue = (resultValue + _values[i]) * 10;
            }
            else
            {
                resultValue += _values[i];
            }
        }

        return resultValue;
    }

    void Clear()
    {
        for (int i = 0; i<5; i++)
        {
            _values[i] = -1;
        }

        index = 0;
    }
};

class ViewManager
{
public:

    void SetView(Views view)
    {
        switch (view)
        {
            case LOGIN_VIEW: SetView("Podaj Login"); break;
            case PASSWORD_VIEW:SetView("Haslo"); break;
            case ERROR_VIEW: SetView("Error"); break;
            case USSER_VIEW: SetView("Witaj!"); break;
            case CHANGE_PASSWORD_VIEW_LOGIN:SetView("Podaj Login"); break;
            case CHANGE_PASSWORD_VIEW_OLD_PASSWORD:SetView("Old password"); break;
            case CHANGE_PASSWORD_VIEW_PASSWORD1:SetView("Nowe haslo"); break;
            case CHANGE_PASSWORD_VIEW_PASSWORD2:SetView("Potwierdz"); break;
            case ADD_USER_LOGIN:SetView("Podaj Login"); break;
            case ADD_USER_PASSWORD:SetView("Podaj haslo"); break;
            case ADD_USER_CONFIRM_PASSWORD:SetView("Potwierdz haslo"); break;
            default:
                break;
        }
    }

    static void Clear()
    {
        lcd.clear();
    }

private:
    void SetView(String content)
    {
        Clear();
        lcd.print(content);
        lcd.setCursor(0, 1);
    }
}; ViewManager viewManager;

class ActionManager
{
    Views _currentView;
    ValueWrapper _valueWrapper;
    EpromAccessService _accessService;
    short _newPassword;
    unsigned long time;

    void OnLoginView()
    {
        short id = _valueWrapper.GetValue();
        User currentUser = _accessService.GetUserById(id);
        if (!currentUser.IsEmpty())
        {
            viewManager.SetView(PASSWORD_VIEW);
            SetCurrentView(PASSWORD_VIEW);
        }
        else
        {
            OnError(LOGIN_VIEW);
        }
    }

    void OnPasswordView()
    {
        User currentUser = _accessService.GetCurrentUser();
        if (!currentUser.IsEmpty())
        {
            short password = _valueWrapper.GetValue();
            if (password == currentUser.GetPassword())
            {
                viewManager.SetView(USSER_VIEW);
                SetCurrentView(USSER_VIEW);
                digitalWrite(led, LOW);
            }
            else
            {
                OnError(PASSWORD_VIEW);
            }
        }
    }

    void OnUserView()
    {
        short number = _valueWrapper.GetValue();
        Serial.print(number);
        switch (number)
        {
        case CHANGE_PASSWORD_VIEW_LOGIN:
            viewManager.SetView(CHANGE_PASSWORD_VIEW_LOGIN);
            SetCurrentView(CHANGE_PASSWORD_VIEW_LOGIN);
            break;
        case ADD_USER_LOGIN:viewManager.SetView(ADD_USER_LOGIN);
            SetCurrentView(ADD_USER_LOGIN);
            break;
        default: OnError(USSER_VIEW);
            break;
        }
    }

    void OnChangePasswordLogin()
    {
        User user = _accessService.GetCurrentUser();
        short login = _valueWrapper.GetValue();
        if (login == user.GetLogin())
        {
            viewManager.SetView(CHANGE_PASSWORD_VIEW_OLD_PASSWORD);
            SetCurrentView(CHANGE_PASSWORD_VIEW_OLD_PASSWORD);
        }
        else
        {
            OnError(CHANGE_PASSWORD_VIEW_LOGIN);
        }
    }

    void OnChangeOldPassword()
    {
        User user = _accessService.GetCurrentUser();
        short oldPassword = _valueWrapper.GetValue();

        if (user.GetPassword() == oldPassword)
        {
            viewManager.SetView(CHANGE_PASSWORD_VIEW_PASSWORD1);
            SetCurrentView(CHANGE_PASSWORD_VIEW_PASSWORD1);
        }
        else
        {
            OnError(CHANGE_PASSWORD_VIEW_OLD_PASSWORD);
        }
    }

    void OnChangePasswordNewPassword()
    {
        _newPassword = _valueWrapper.GetValue();
        viewManager.SetView(CHANGE_PASSWORD_VIEW_PASSWORD2);
        SetCurrentView(CHANGE_PASSWORD_VIEW_PASSWORD2);
    }

    void OnConfirmPassword()
    {
        short password = _valueWrapper.GetValue();
        if (password == _newPassword)
        {
            viewManager.SetView(USSER_VIEW);
            SetCurrentView(USSER_VIEW);
            User user = _accessService.GetCurrentUser();
            user.SetPassword(password);
            _accessService.UpdateUser(user);
        }
        else
        {
            OnError(CHANGE_PASSWORD_VIEW_PASSWORD2);
        }
    }

    short _login;
    void OnAddUserLogin()
    {
        _login = _valueWrapper.GetValue();
        viewManager.SetView(ADD_USER_PASSWORD);
        SetCurrentView(ADD_USER_PASSWORD);
    }

    short _newUserPassword;
    void OnAddUserPassword()
    {
        _newUserPassword = _valueWrapper.GetValue();
        viewManager.SetView(ADD_USER_CONFIRM_PASSWORD);
        SetCurrentView(ADD_USER_CONFIRM_PASSWORD);
    }

    void OnConfirmAddUserPassword()
    {
        short password = _valueWrapper.GetValue();
        if (password == _newUserPassword)
        {
            User newUser = User();
            newUser.SetPassword(password);
            newUser.SetLogin(_login);
            SetCurrentView(USSER_VIEW);
            _accessService.AddUser(newUser);
            viewManager.SetView(USSER_VIEW);
        }
        else
        {
            OnError(ADD_USER_CONFIRM_PASSWORD);
        }
    }

    void OnError(Views afterError)
    {
        viewManager.SetView(ERROR_VIEW);
        delay(2000);
        viewManager.SetView(afterError);
    }

    void SetCurrentView(Views view)
    {
        if (view == USSER_VIEW)
        {
            digitalWrite(led, LOW);
            time = millis();
        }
        else
        {
            digitalWrite(led, HIGH);
        }
        _currentView = view;
    }

public:
    ActionManager()
    {
        _valueWrapper = ValueWrapper();
        _currentView = LOGIN_VIEW;
    }

    void OnKey(short value)
    {
        if (value == CONFIRM)
        {
            switch (_currentView)
            {
                case LOGIN_VIEW: OnLoginView(); break;
                case PASSWORD_VIEW: OnPasswordView(); break;
                case USSER_VIEW:OnUserView(); break;
                case CHANGE_PASSWORD_VIEW_LOGIN:OnChangePasswordLogin(); break;
                case CHANGE_PASSWORD_VIEW_OLD_PASSWORD:OnChangeOldPassword(); break;
                case CHANGE_PASSWORD_VIEW_PASSWORD1:OnChangePasswordNewPassword(); break;
                case CHANGE_PASSWORD_VIEW_PASSWORD2:OnConfirmPassword(); break;
                case ADD_USER_LOGIN:OnAddUserLogin(); break;
                case ADD_USER_PASSWORD:OnAddUserPassword(); break;
                case ADD_USER_CONFIRM_PASSWORD:OnConfirmAddUserPassword(); break;
                default:break;
            }
            _valueWrapper.Clear();
        }
        else
        {
            _valueWrapper.AddValue(value);
        }
    }

    void Check()
    {
        if (_currentView == USSER_VIEW)
        {
            if (millis() - time > 15000)
            {
                viewManager.SetView(LOGIN_VIEW);
                SetCurrentView(LOGIN_VIEW);
                digitalWrite(led, HIGH);
            }
        }
    }
};
ActionManager actionManager;

const int BUTTONS_L[] = { 8,9,10 };
const int BUTTONS_R[4] = { A0,A1,A2,A3 };
short lastValueR = -1;
short lastValueL = -1;
short int m = 0;
ValueWrapper wrapper;

void setup()
{
    /*for (int i = 0; i < EEPROM.length(); i++) {
        EEPROM.write(i, -1);
    }*/
    lcd.begin(16, 2);
    Serial.begin(9600);
    pinMode(led, OUTPUT);
    digitalWrite(led, HIGH);

    History a = History();

    for (int i = 0; i< 3; i++)
    {
        pinMode(BUTTONS_L[i], OUTPUT);
        digitalWrite(BUTTONS_L[i], HIGH);
    }
    for (int i = 0; i< 4; i++)
    {
        pinMode(BUTTONS_R[i], INPUT_PULLUP);
        digitalWrite(BUTTONS_R[i], HIGH);
    }

    actionManager = ActionManager();
    wrapper = ValueWrapper();
    viewManager = ViewManager();
    viewManager.SetView(LOGIN_VIEW);
}

void loop()
{
    for (int i = 0; i<3; i++)
    {
        digitalWrite(BUTTONS_L[i], LOW);
        for (int j = 0; j<4; j++)
        {
            int rValue = digitalRead(BUTTONS_R[j]);
            if (rValue == LOW)
            {
                m++;
                if (m>40)
                {
                    if (!(lastValueR == BUTTONS_R[j] && lastValueL == BUTTONS_L[i]))
                    {
                        lastValueR = BUTTONS_R[j];
                        lastValueL = BUTTONS_L[i];
                        short currentValue = j * 3 + i;
                        actionManager.OnKey(currentValue);
                        if (currentValue != CONFIRM)
                        {
                            lcd.print(currentValue);
                        }
                    }
                    m = 0;
                }
                digitalWrite(BUTTONS_L[i], HIGH);
            }
            else
            {
                actionManager.Check();
            }
        }
    }
}