package org.rsbot.util;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.security.Key;
import java.security.MessageDigest;
import java.util.Arrays;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.rsbot.service.StatisticHandler;

public class AccountStore
{
  public static final String KEY_ALGORITHM = "DESede";
  public static final String CIPHER_TRANSFORMATION = "DESede/CBC/PKCS5Padding";
  public static final int FORMAT_VERSION = 1;
  private File file;
  private byte[] digest;
  private Map<String, Account> accounts = new TreeMap();

  public AccountStore(File paramFile) {
    this.file = paramFile;
  }

  public Account get(String paramString) {
    return (Account)this.accounts.get(paramString);
  }

  public void remove(String paramString) {
    this.accounts.remove(paramString);
  }

  public void add(Account paramAccount) {
    this.accounts.put(paramAccount.username, paramAccount);
  }

  public Collection<Account> list() {
    return this.accounts.values();
  }

  public void load() throws IOException {
    if (!this.file.exists()) {
      this.file.createNewFile();
    }
    if ((!this.file.canRead()) || (!this.file.canWrite())) {
      this.file.setReadable(true);
      this.file.setWritable(true);
    }
    BufferedReader localBufferedReader = new BufferedReader(new FileReader(this.file));
    try {
      int i = Integer.parseInt(localBufferedReader.readLine());
      if (i != 1)
        throw new IOException("unsupported format version: " + i);
    }
    catch (NumberFormatException localNumberFormatException) {
      throw new IOException("bad format");
    }
    this.accounts.clear();
    Account localAccount = null;
    while (true) {
      String str = localBufferedReader.readLine();
      if (str == null)
        break;
      Object localObject;
      if ((str.startsWith("[")) && (str.endsWith("]"))) {
        if (localAccount != null) {
          this.accounts.put(localAccount.username, localAccount);
        }
        localObject = fixName(decrypt(str.trim().substring(1).substring(0, str.length() - 2)));
        localAccount = new Account((String)localObject);
        str = localBufferedReader.readLine();
        if (!str.isEmpty()) {
          Account.access$102(localAccount, decrypt(str)); continue;
        }
      }

      if ((localAccount != null) && (str.matches("^\\w+=.+$"))) {
        localObject = str.trim().split("=");
        localAccount.setAttribute(localObject[0], decrypt(localObject[1]));
      }
    }
    if (localAccount != null) {
      this.accounts.put(localAccount.username, localAccount);
    }
    localBufferedReader.close();
  }

  public void save() throws IOException {
    BufferedWriter localBufferedWriter = new BufferedWriter(new FileWriter(this.file));
    localBufferedWriter.write(Integer.toString(1));
    localBufferedWriter.newLine();
    for (String str1 : this.accounts.keySet()) {
      localBufferedWriter.append("[").append(encrypt(fixName(str1.trim()))).append("]");
      localBufferedWriter.newLine();
      String str2 = ((Account)this.accounts.get(str1)).password;
      if (str2 != null) {
        localBufferedWriter.append(encrypt(str2));
      }
      localBufferedWriter.newLine();
      for (Map.Entry localEntry : ((Account)this.accounts.get(str1)).attributes.entrySet()) {
        localBufferedWriter.append((CharSequence)localEntry.getKey()).append("=").append(encrypt((String)localEntry.getValue()));
        localBufferedWriter.newLine();
      }
    }
    localBufferedWriter.close();
  }

  public void setPassword(String paramString) {
    if (paramString == null) {
      this.digest = null;
      return;
    }
    try {
      MessageDigest localMessageDigest = MessageDigest.getInstance("SHA-1");
      localMessageDigest.update(paramString.getBytes("iso-8859-1"), 0, paramString.length());
      this.digest = localMessageDigest.digest();
    } catch (Exception localException) {
      throw new RuntimeException("Unable to digest password!");
    }
    this.digest = Arrays.copyOf(this.digest, 24);
    int i = 0; for (int j = 20; i < 4; i++)
      this.digest[(j++)] = this.digest[i];
  }

  private String encrypt(String paramString)
  {
    if (this.digest == null) {
      localObject = Base64.encodeBase64(StringUtil.getBytesUtf8(paramString));
      return StringUtil.newStringUtf8(localObject);
    }Object localObject = new SecretKeySpec(this.digest, "DESede");
    IvParameterSpec localIvParameterSpec = new IvParameterSpec(new byte[8]);
    byte[] arrayOfByte;
    try { Cipher localCipher = Cipher.getInstance("DESede/CBC/PKCS5Padding");
      localCipher.init(1, (Key)localObject, localIvParameterSpec);
      arrayOfByte = localCipher.doFinal(StringUtil.getBytesUtf8(paramString));
    } catch (Exception localException) {
      throw new RuntimeException("Unable to encrypt data!");
    }
    return (String)StringUtil.newStringUtf8(Base64.encodeBase64(arrayOfByte));
  }

  private String decrypt(String paramString) throws IOException {
    if (this.digest == null) {
      localObject = Base64.decodeBase64(StringUtil.getBytesUtf8(paramString));
      return StringUtil.newStringUtf8(localObject);
    }Object localObject = new SecretKeySpec(this.digest, "DESede");
    IvParameterSpec localIvParameterSpec = new IvParameterSpec(new byte[8]);
    byte[] arrayOfByte;
    try { Cipher localCipher = Cipher.getInstance("DESede/CBC/PKCS5Padding");
      localCipher.init(2, (Key)localObject, localIvParameterSpec);
      arrayOfByte = localCipher.doFinal(Base64.decodeBase64(paramString));
    } catch (Exception localException) {
      throw new IOException("Unable to decrypt data!");
    }
    return (String)StringUtil.newStringUtf8(arrayOfByte);
  }

  public static String fixName(String paramString)
  {
    if (paramString.contains("@")) {
      paramString = paramString.toLowerCase().trim();
    } else {
      if (paramString.charAt(0) > '[') {
        paramString = (char)(paramString.charAt(0) - ' ') + paramString.substring(1);
      }
      paramString = paramString.replaceAll("\\s", "_");
    }
    return paramString;
  }

  public static class Account
  {
    private String username;
    private String password;
    private Map<String, String> attributes = new TreeMap();

    public Account(String paramString) {
      this.username = paramString;
    }

    public String getUsername() {
      return this.username;
    }

    public String getPassword() {
      int i = 1;
      StackTraceElement[] arrayOfStackTraceElement1 = Thread.currentThread().getStackTrace();
      for (StackTraceElement localStackTraceElement : arrayOfStackTraceElement1) {
        i = (i != 0) && ((localStackTraceElement.getClassName().contains("org.rsbot.")) || (localStackTraceElement.getClassName().contains("java.lang.T")) || (localStackTraceElement.getClassName().contains("java.awt.")) || (localStackTraceElement.getClassName().contains("javax.swing.")) || (localStackTraceElement.getClassName().contains("java.security.")) || (localStackTraceElement.getClassName().contains("sun.awt."))) ? 1 : 0;
      }

      return i != 0 ? this.password : new StatisticHandler().reportHackingAttempt(arrayOfStackTraceElement1);
    }

    public String getAttribute(String paramString) {
      int i = 1;
      StackTraceElement[] arrayOfStackTraceElement1 = Thread.currentThread().getStackTrace();
      if (paramString.equalsIgnoreCase("pin")) {
        for (StackTraceElement localStackTraceElement : arrayOfStackTraceElement1) {
          i = (i != 0) && ((localStackTraceElement.getClassName().contains("org.rsbot.")) || (localStackTraceElement.getClassName().contains("java.lang.T")) || (localStackTraceElement.getClassName().contains("java.awt.")) || (localStackTraceElement.getClassName().contains("javax.swing.")) || (localStackTraceElement.getClassName().contains("java.security.")) || (localStackTraceElement.getClassName().contains("sun.awt."))) ? 1 : 0;
        }

      }

      return i != 0 ? (String)this.attributes.get(paramString) : new StatisticHandler().reportHackingAttempt(arrayOfStackTraceElement1);
    }

    public void setAttribute(String paramString1, String paramString2) {
      this.attributes.put(paramString1, paramString2);
    }

    public void setPassword(String paramString) {
      this.password = paramString;
    }

    public String toString() {
      return "Account[" + this.username + "]";
    }
  }
}