auth.cpp

#include "auth.h"
#include <iostream>
#include <iomanip>
#include <ctime>
#include <fstream>
#include <limits>
#include <cctype>
#include "vault.h"
#include "../security/security.h"

std::vector<Entry> Auth::decoyData;

Auth::Auth(Config& cfg) : config(cfg), attempts(0), isRealAccess(false), currentVault(nullptr), masterPassword("") {
    initDecoyData();
}

Auth::~Auth() {
    if (currentVault) delete currentVault;
}

void Auth::initDecoyData() {
    decoyData = {
        {"Gmail", "john.doe@gmail.com", "mypass123", "Social", "2026-03-15 10:30"},
        {"Instagram", "johndoe", "insta123", "Social", "2026-02-20 14:22"},
        {"Chase Bank", "john.doe@bank.com", "bank456", "Finance", "2026-01-10 09:15"}
    };
}

std::string Auth::getPasswordInput(const std::string& prompt) {
    std::string input;
    std::cout << prompt;
    std::cin >> input;
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    return input;
}

bool Auth::fileExists(const std::string& filename) {
    std::ifstream file(filename);
    return file.good();
}

bool Auth::isSystemResetRequired() {
    bool masterExists = fileExists("data/master.txt");
    bool vaultExists = fileExists("data/vault.txt");
    
    if (!masterExists || !vaultExists) {
        return true;
    }
    
    std::ifstream masterCheck("data/master.txt");
    std::ifstream vaultCheck("data/vault.txt");
    
    masterCheck.seekg(0, std::ios::end);
    vaultCheck.seekg(0, std::ios::end);
    
    bool masterEmpty = (masterCheck.tellg() == 0);
    bool vaultEmpty = (vaultCheck.tellg() == 0);
    
    masterCheck.close();
    vaultCheck.close();
    
    return masterEmpty || vaultEmpty;
}

void Auth::initialSetup() {
    if (isSystemResetRequired()) {
        std::cout << "\n[!] SYSTEM RESET DETECTED - Full Re-initialization\n";
        std::cout << "[X] Previous vault was destroyed. Setting up NEW system\n\n";
        
        std::remove("data/master.txt");
        std::remove("data/vault.txt");
        
        std::cout << "[*] CREATE NEW MASTER PASSWORD\n";
        std::cout << "[?] 1st RUN: Set your own Master Password\n\n";
        
        std::string pwd1, pwd2;
        do {
            pwd1 = getPasswordInput("[+] New Master Password: ");
            pwd2 = getPasswordInput("[R] Confirm Password: ");
            
            if (pwd1 != pwd2) {
                std::cout << "[!] Passwords don't match! Try again.\n\n";
            } else if (pwd1.length() < 6) {
                std::cout << "[!] Password too short! Use at least 6 characters.\n\n";
            }
        } while (pwd1 != pwd2 || pwd1.length() < 6);
        
        masterPassword = pwd1;
        
        std::ofstream masterOut("data/master.txt");
        masterOut << masterPassword;
        masterOut.close();
        
        std::ofstream vaultReset("data/vault.txt", std::ios::trunc);
        vaultReset.close();
        
        std::cout << "[OK] NEW Master Password set successfully!\n";
        std::cout << "[*] Fresh vault initialized. Stay safe!\n\n";
        std::cin.get();
    } else {
        std::ifstream masterFile("data/master.txt");
        if (masterFile.good()) {
            masterFile >> masterPassword;
            masterFile.close();
        }
    }
}

bool Auth::checkSpecialCondition() {
    static bool firstAttempt = true;
    bool result = firstAttempt;
    firstAttempt = false;
    return result;
}

void Auth::showDecoyMessage() {
    std::cout << "\n[+] Vault decrypted successfully!\n";
    std::cout << "[*] Secured with AES-256 + RSA encryption\n\n";
}

void Auth::authenticate() {
    if (masterPassword.empty()) {
        std::cout << "\n[!] No master password configured. Run initial setup first.\n";
        initialSetup();
        return;
    }
    
    std::string input = getPasswordInput("\n[+] Enter Master Password: ");
    
    bool correctPassword = (input == masterPassword);
    
    if (correctPassword && checkSpecialCondition()) {
        std::cout << "\n[OK] ACCESS GRANTED TO SECURE VAULT!\n";
        std::cout << "[*] REAL vault active - All features unlocked\n\n";
        if (currentVault) delete currentVault;
        currentVault = new Vault("data/vault.txt", true);
        isRealAccess = true;
    } else {
        attempts++;
        if (correctPassword) {
            std::cout << "\n[!] Special access condition failed (1st attempt only)\n";
        }
        showDecoyMessage();
        if (currentVault) delete currentVault;
        currentVault = new Vault("data/decoy.txt", false);
        isRealAccess = false;
        
        std::cout << "[*] Attempts: " << attempts << "/" << config.getMaxAttempts() << "\n";
        
        if (attempts >= config.getMaxAttempts()) {
            triggerSelfDestruct();
            attempts = 0;
        }
    }
}

void Auth::viewCurrentVault() {
    if (currentVault) {
        std::cout << "\n" << (isRealAccess ? "[*] REAL VAULT ACTIVE" : "[*] DECOY VAULT ACTIVE") << "\n";
        currentVault->viewEntriesWithStrength();
    } else {
        std::cout << "[!] No vault active. Authenticate first.\n\n";
    }
}

void Auth::addToCurrentVault() {
    if (currentVault) {
        std::cout << (isRealAccess ? "[*] Adding to REAL vault" : "[*] Adding to DECOY (temporary)") << "\n";
        currentVault->addEntry(isRealAccess);
    } else {
        std::cout << "[!] No vault active. Authenticate first.\n\n";
    }
}

void Auth::searchEntry() {
    if (!currentVault) {
        std::cout << "[!] No vault active.\n\n";
        return;
    }
    
    std::string searchTerm;
    std::cout << "\n[?] Enter search term: ";
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    std::getline(std::cin, searchTerm);
    
    currentVault->searchEntries(searchTerm);
}

void Auth::editCurrentVault() {
    if (currentVault) {
        currentVault->editEntry();
    } else {
        std::cout << "[!] No vault active.\n\n";
    }
}

void Auth::checkPasswordStrength() {
    std::string pwd;
    std::cout << "\n[?] Enter password to analyze: ";
    std::cin >> pwd;
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    
    int score = 0;
    if (pwd.length() >= 8) score++;
    bool hasUpper = false, hasLower = false, hasDigit = false, hasSpecial = false;
    
    for (char c : pwd) {
        if (isupper(c)) hasUpper = true;
        if (islower(c)) hasLower = true;
        if (isdigit(c)) hasDigit = true;
        if (!isalnum(c)) hasSpecial = true;
    }
    if (hasUpper) score++; 
    if (hasLower) score++; 
    if (hasDigit) score++; 
    if (hasSpecial) score++;
    
    std::cout << "\n[*] STRENGTH ANALYSIS:\n";
    std::cout << " ├─ Length: " << (pwd.length() >= 8 ? "[+] GOOD" : "[-] WEAK") << "\n";
    std::cout << " ├─ Uppercase: " << (hasUpper ? "[+] YES" : "[-] NO") << "\n";
    std::cout << " ├─ Lowercase: " << (hasLower ? "[+] YES" : "[-] NO") << "\n";
    std::cout << " ├─ Numbers: " << (hasDigit ? "[+] YES" : "[-] NO") << "\n";
    std::cout << " └─ Special: " << (hasSpecial ? "[+] YES" : "[-] NO") << "\n";
    
    std::cout << "[*] RESULT: ";
    if (score <= 2) std::cout << "[-] WEAK";
    else if (score <= 3) std::cout << "[~] MEDIUM";
    else std::cout << "[+] STRONG";
    std::cout << " (" << score << "/5)\n\n";
}

void Auth::revealPasswordInVault() {
    if (!currentVault || !isRealAccess) {
        std::cout << "\n[!] REAL VAULT + ADMIN PASSWORD REQUIRED!\n\n";
        return;
    }
    
    std::string adminPwd = getPasswordInput("\n[+] Admin Password (Master Password): ");
    if (adminPwd != masterPassword) {
        std::cout << "\n[!] Admin authentication failed!\n";
        std::cout << "[*] Vault remains secure.\n\n";
        return;
    }
    
    currentVault->viewEntriesWithStrength();
    std::cout << "\n[+] Select entry number to DECRYPT: ";
    size_t index;
    std::cin >> index;
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    
    currentVault->revealPassword(index - 1);
}

void Auth::logoutReauthenticate() {
    if (currentVault) {
        delete currentVault;
        currentVault = nullptr;
    }
    std::cout << "\n[!] Session logged out. Re-authenticating...\n";
    authenticate();
}

void Auth::triggerSelfDestruct() {
    std::cout << "\n[!] SELF-DESTRUCT ACTIVATED! WIPING ALL DATA.\n";
    std::cout << "[!] Master Password RESET\n";
    std::cout << "[!] Next RUN: You will set NEW master password\n\n";
    
    std::remove("data/master.txt");
    std::remove("data/vault.txt");
    
    std::cout << "[OK] Self-destruct COMPLETE. System fully reset.\n";
    std::cout << "[*] Vault locked. Stay safe!\n\n";
    
    if (currentVault) {
        delete currentVault;
        currentVault = nullptr;
        masterPassword = "";
    }
}