/// <reference path="../decl/urijs/URIjs.d.ts" />
/// <reference path="../decl/chrome/chrome.d.ts" />
'use strict';

const DB_NAME = "taler";
const DB_VERSION = 1;


/**
 * Return a promise that resolves
 * to the taler wallet db.
 */
function openTalerDb(): Promise<IDBDatabase> {
  return new Promise((resolve, reject) => {
    let req = indexedDB.open(DB_NAME, DB_VERSION);
    req.onerror = (e) => {
      reject(e);
    };
    req.onsuccess = (e) => {
      resolve(req.result);
    };
    req.onupgradeneeded = (e) => {
      let db = req.result;
      console.log ("DB: upgrade needed: oldVersion = " + e.oldVersion);
      switch (e.oldVersion) {
        case 0: // DB does not exist yet
          db.createObjectStore("mints", { keyPath: "baseUrl" });
          db.createObjectStore("reserves", { keyPath: "reserve_pub"});
          db.createObjectStore("denoms", { keyPath: "denomPub" });
          let coins = db.createObjectStore("coins", { keyPath: "coinPub" });
          coins.createIndex("mintBaseUrl", "mintBaseUrl");
          db.createObjectStore("transactions", { keyPath: "contractHash" });
          db.createObjectStore("precoins", { keyPath: "coinPub", autoIncrement: true });
          break;
      }
    };
  });
}


/**
 * See http://api.taler.net/wallet.html#general
 */
function canonicalizeBaseUrl(url) {
  let x = new URI(url);
  if (!x.protocol()) {
    x.protocol("https");
  }
  x.path(x.path() + "/").normalizePath();
  x.fragment();
  x.query();
  return x.href()
}

interface ConfirmPayRequest {
  offer: any;
  selectedMint: any;
}


function grantCoins(db: IDBDatabase,
                    feeThreshold: AmountJson,
                    paymentAmount: AmountJson,
                    mintBaseUrl: string): Promise<any> {
  throw "not implemented";
}


function confirmPay(db, detail: ConfirmPayRequest, sendResponse) { 
  console.log("confirmPay", JSON.stringify(detail));
  let tx = db.transaction(['transactions'], 'readwrite');
  let trans = {
    contractHash: detail.offer.H_contract,
    contract: detail.offer.contract,
    sig: detail.offer
  }

  let contract = detail.offer.contract;

  //let chosenCoinPromise = chooseCoins(db, contract.max_fee, contract.amount)
  //    .then(x => generateDepositPermissions(db, x))
  //    .then(executePayment);

  return true;
}

function confirmReserve(db, detail, sendResponse) {
  let reservePriv = EddsaPrivateKey.create();
  let reservePub = reservePriv.getPublicKey();
  let form = new FormData();
  let now = (new Date()).toString();
  form.append(detail.field_amount, detail.amount_str);
  form.append(detail.field_reserve_pub, reservePub.toCrock());
  form.append(detail.field_mint, detail.mint);
  // XXX: set bank-specified fields.
  let myRequest = new XMLHttpRequest();
  console.log("making request to " + detail.post_url);
  myRequest.open('post', detail.post_url);
  myRequest.send(form);
  let mintBaseUrl = canonicalizeBaseUrl(detail.mint);
  myRequest.addEventListener('readystatechange', (e) => {
    if (myRequest.readyState == XMLHttpRequest.DONE) {
      // TODO: extract as interface
      let resp = {
        status: myRequest.status,
        text: myRequest.responseText,
        success: undefined,
        backlink: undefined
      };
      let reserveRecord = {
        reserve_pub: reservePub.toCrock(),
        reserve_priv: reservePriv.toCrock(),
        mint_base_url: mintBaseUrl,
        created: now,
        last_query: null,
        current_amount: null,
        // XXX: set to actual amount
        initial_amount: null
      };
      // XXX: insert into db.
      switch (myRequest.status) {
        case 200:
          resp.success = true;
          // We can't show the page directly, so
          // we show some generic page from the wallet.
          resp.backlink = chrome.extension.getURL("pages/reserve-success.html");
          let tx = db.transaction(['reserves'], 'readwrite');
          tx.objectStore('reserves').add(reserveRecord);
          tx.addEventListener('complete', (e) => {
            console.log('tx complete, pk was ' + reserveRecord.reserve_pub);
            sendResponse(resp);
            var mint;
            updateMintFromUrl(db, reserveRecord.mint_base_url)
                .then((m) => { mint = m; return updateReserve(db, reservePub, mint); })
                .then((reserve) => depleteReserve(db, reserve, mint));
          });
          break;
        default:
          resp.success = false;
          sendResponse(resp);
      }
    }
  });
  // Allow async response
  return true;
}


function copy(o) {
  return JSON.parse(JSON.stringify(o));
}


function rankDenom(denom1: any, denom2: any) {
  // Slow ... we should find a better way than to convert it evert time.
  let v1 = new Amount(denom1.value);
  let v2 = new Amount(denom2.value);
  return (-1) * v1.cmp(v2);
}


function withdrawPrepare(db: IDBDatabase,
                         denom: Denomination,
                         reserve): Promise<PreCoin> {
  let reservePriv = new EddsaPrivateKey();
  reservePriv.loadCrock(reserve.reserve_priv);
  let reservePub = new EddsaPublicKey();
  reservePub.loadCrock(reserve.reserve_pub);
  let denomPub = RsaPublicKey.fromCrock(denom.denom_pub);
  let coinPriv = EddsaPrivateKey.create();
  let coinPub = coinPriv.getPublicKey();
  let blindingFactor = RsaBlindingKey.create(1024);
  let pubHash: HashCode = coinPub.hash();
  let ev: ByteArray = rsaBlind(pubHash, blindingFactor, denomPub);

  if (!denom.fee_withdraw) {
    throw Error("Field fee_withdraw missing");
  }

  let amountWithFee = new Amount(denom.value);
  amountWithFee.add(new Amount(denom.fee_withdraw));
  let withdrawFee = new Amount(denom.fee_withdraw);

  // Signature
  let withdrawRequest = new WithdrawRequestPS({
    reserve_pub: reservePub,
    amount_with_fee: amountWithFee.toNbo(),
    withdraw_fee: withdrawFee.toNbo(),
    h_denomination_pub: denomPub.encode().hash(),
    h_coin_envelope: ev.hash()
  });

  console.log("about to sign");
  var sig = eddsaSign(withdrawRequest.toPurpose(), reservePriv);
  console.log("signed");

  console.log("crypto done, doing request");

  let preCoin: PreCoin = {
    reservePub: reservePub.toCrock(),
    blindingKey: blindingFactor.toCrock(),
    coinPub: coinPub.toCrock(),
    coinPriv: coinPriv.toCrock(),
    denomPub: denomPub.encode().toCrock(),
    mintBaseUrl: reserve.mintBaseUrl,
    withdrawSig: sig.toCrock(),
    coinEv: ev.toCrock(),
    coinValue: denom.value
  };

  console.log("storing precoin", JSON.stringify(preCoin));

  let tx = db.transaction(['precoins'], 'readwrite');
  tx.objectStore('precoins').add(preCoin);
  return new Promise((resolve, reject) => {
    tx.oncomplete = (e) => {
      resolve(preCoin);
    }
  });
}

function dbGet(db, store: string, key: any): Promise<any> {
  let tx = db.transaction([store]);
  let req = tx.objectStore(store).get(key);
  return new Promise((resolve, reject) => {
    req.onsuccess = (e) => resolve(req.result); 
  });
}


function withdrawExecute(db, pc: PreCoin): Promise<Coin> {
  return dbGet(db, 'reserves', pc.reservePub)
      .then((r) => new Promise((resolve, reject) => {
        console.log("loading precoin", JSON.stringify(pc));
          let wd: any = {};
          wd.denom_pub = pc.denomPub;
          wd.reserve_pub = pc.reservePub;
          wd.reserve_sig = pc.withdrawSig;
          wd.coin_ev = pc.coinEv;
          let reqUrl = URI("reserve/withdraw").absoluteTo(r.mint_base_url);
          let myRequest = new XMLHttpRequest();
          console.log("making request to " + reqUrl.href());
          myRequest.open('post', reqUrl.href());
          myRequest.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
          myRequest.send(JSON.stringify(wd));
          myRequest.addEventListener('readystatechange', (e) => {
            if (myRequest.readyState == XMLHttpRequest.DONE) {
              if (myRequest.status != 200) {
                console.log("Withdrawal failed, status ", myRequest.status);
                reject();
                return;
              }
              console.log("Withdrawal successful");
              console.log(myRequest.responseText);
              let resp = JSON.parse(myRequest.responseText);
              let denomSig = rsaUnblind(RsaSignature.fromCrock(resp.coin_ev),
                                          RsaBlindingKey.fromCrock(pc.blindingKey),
                                          RsaPublicKey.fromCrock(pc.denomPub));
              let coin: Coin = {
                coinPub: pc.coinPub,
                coinPriv: pc.coinPriv,
                denomPub: pc.denomPub,
                denomSig:  denomSig.encode().toCrock(),
                currentAmount: pc.coinValue
              }
              console.log("unblinded coin");
              resolve(coin);
            } else {
              console.log("ready state change to", myRequest.status);
            }
          });
      }));
}


function updateBadge(db) {
  let tx = db.transaction(['coins'], 'readwrite');
  let req = tx.objectStore('coins').openCursor();
  let n = 0;
  req.onsuccess = (e) => {
    let cursor = req.result;
    if (cursor) {
      n++;
      cursor.continue();
    } else {
      console.log("badge");
      chrome.browserAction.setBadgeText({text: ""+n});
      chrome.browserAction.setBadgeBackgroundColor({color: "#0F0"});
    }
  }
}


function storeCoin(db, coin: Coin) {
  let tx = db.transaction(['coins', 'precoins'], 'readwrite');
  tx.objectStore('precoins').delete(coin.coinPub);
  tx.objectStore('coins').add(coin);
  return new Promise<void>((resolve, reject) => {
    tx.oncomplete = (e) => {
      resolve();
      updateBadge(db);
    }
  });
}


function withdraw(db, denom, reserve): Promise<void> {
  return withdrawPrepare(db, denom, reserve)
      .then((pc) => withdrawExecute(db, pc))
      .then((c) => storeCoin(db, c));
}


/**
 * Withdraw coins from a reserve until it is empty.
 */
function depleteReserve(db, reserve, mint) {
  let denoms = copy(mint.keys.denoms);
  let remaining = new Amount(reserve.current_amount);
  denoms.sort(rankDenom);
  let workList = [];
  for (let i = 0; i < 1000; i++) {
    let found = false;
    for (let d of denoms) {
      let cost = new Amount(d.value);
      cost.add(new Amount(d.fee_withdraw));
      if (remaining.cmp(cost) < 0) {
        continue;
      }
      found = true;
      remaining.sub(cost);
      workList.push(d);
    }
    if (!found) {
      break;
    }
  }

  // Do the request one by one.
  function next(): void {
    if (workList.length == 0) {
      return;
    }
    console.log("doing work");
    let d = workList.pop();
    withdraw(db, d, reserve)
        .then(() => next());
  }

  next();
}


function updateReserve(db, reservePub: EddsaPublicKey, mint) {
  let reserve;
  return new Promise((resolve, reject) => {
    let tx = db.transaction(['reserves']);
    tx.objectStore('reserves').get(reservePub.toCrock()).onsuccess = (e) => {
      let reserve = e.target.result;
      let reqUrl = URI("reserve/status").absoluteTo(mint.baseUrl);
      reqUrl.query({'reserve_pub': reservePub.toCrock()});
      let myRequest = new XMLHttpRequest();
      console.log("making request to " + reqUrl.href());
      myRequest.open('get', reqUrl.href());
      myRequest.send();
      myRequest.addEventListener('readystatechange', (e) => {
        if (myRequest.readyState == XMLHttpRequest.DONE) {
          if (myRequest.status != 200) {
            reject();
            return;
          }
          let reserveInfo = JSON.parse(myRequest.responseText);
          console.log("got response " + JSON.stringify(reserveInfo));
          reserve.current_amount = reserveInfo.balance;
          let tx = db.transaction(['reserves'], 'readwrite');
          console.log("putting updated reserve " + JSON.stringify(reserve));
          tx.objectStore('reserves').put(reserve);
          tx.oncomplete = (e) => {
            resolve(reserve);
          };
        }
      });
    };
  });

}


/**
 * Update or add mint DB entry by fetching the /keys information.
 * Optionally link the reserve entry to the new or existing
 * mint entry in then DB.
 */
function updateMintFromUrl(db, baseUrl) {
  console.log("base url is " + baseUrl);
  let reqUrl = URI("keys").absoluteTo(baseUrl);
  let myRequest = new XMLHttpRequest();
  myRequest.open('get', reqUrl.href());
  myRequest.send();
  return new Promise((resolve, reject) => {
    myRequest.addEventListener('readystatechange', (e) => {
      console.log("state change to " + myRequest.readyState);
      if (myRequest.readyState == XMLHttpRequest.DONE) {
        if (myRequest.status == 200) {
          console.log("got /keys");
          let mintKeysJson = JSON.parse(myRequest.responseText);
          if (!mintKeysJson) {
            console.log("keys invalid");
            reject();
          } else {
            let mint = {
              baseUrl: baseUrl,
              keys: mintKeysJson
            };
            let tx = db.transaction(['mints', 'denoms'], 'readwrite');
            tx.objectStore('mints').put(mint);
            for (let d of mintKeysJson.denoms) {
              // TODO: verify and complete
              let di = {
                denomPub: d.denom_pub,
                value: d.value
              }
              tx.objectStore('denoms').put(di);
            }
            tx.oncomplete = (e) => {
              resolve(mint);
            };
          }
        } else {
          console.log("/keys request failed with status " + myRequest.status);
          // XXX: also write last error to DB to show in the UI
          reject();
        }
      }
    });
  });
}


function dumpDb(db, detail, sendResponse) {
  let dump = {
    name: db.name,
    version: db.version,
    stores: {}
  };
  console.log("stores: " + JSON.stringify(db.objectStoreNames));
  let tx = db.transaction(db.objectStoreNames);
  tx.addEventListener('complete', (e) => {
      sendResponse(dump);
  });
  for (let i = 0; i < db.objectStoreNames.length; i++) {
    let name = db.objectStoreNames[i];
    let storeDump = {};
    dump.stores[name] = storeDump;
    let store = tx.objectStore(name).openCursor().addEventListener('success', (e) => {
      let cursor = e.target.result;
      if (cursor) {
        storeDump[cursor.key] = cursor.value;
        cursor.continue();
      }
    });
  }
  return true;
}


// Just for debugging.
function reset(db, detail, sendResponse) {
  let tx = db.transaction(db.objectStoreNames, 'readwrite');
  for (let i = 0; i < db.objectStoreNames.length; i++) {
    tx.objectStore(db.objectStoreNames[i]).clear();
  }
  indexedDB.deleteDatabase(DB_NAME);
  chrome.browserAction.setBadgeText({text: ""});
  console.log("reset done");
  return false;
}


function balances(db, detail, sendResponse) {
  let byCurrency = {};
  let tx = db.transaction(['coins', 'denoms']);
  let req = tx.objectStore('coins').openCursor();
  req.onsuccess = (e) => {
    let cursor = req.result;
    if (cursor) {
      tx.objectStore('denoms').get(cursor.value.denomPub).onsuccess = (e2) => {
        let d = e2.target.result;
        console.log("got denom", JSON.stringify(d));
        let acc = byCurrency[d.value.currency];
        if (!acc) {
          acc = new Amount(d.value);
          console.log("initial:", JSON.stringify(acc.toJson()));
          byCurrency[d.value.currency] = acc.toJson();
        } else {
          let am = new Amount(acc);
          am.add(new Amount(d.value));
          byCurrency[d.value.currency] = am.toJson();
          console.log("then:", JSON.stringify(am.toJson()));
        }
      };
      cursor.continue();
    } else {
      sendResponse(byCurrency);
      console.log("response", JSON.stringify(byCurrency));
    }
  };
  return true;
}

chrome.browserAction.setBadgeText({text: ""});

openTalerDb().then((db) => {
  console.log("db loaded");
  chrome.runtime.onMessage.addListener(
    function (req, sender, onresponse) {
      let dispatch = {
        "confirm-reserve": confirmReserve,
        "confirm-pay": confirmPay,
        "dump-db": dumpDb,
        "balances": balances,
        "reset": reset
      };
      if (req.type in dispatch) {
        return dispatch[req.type](db, req.detail, onresponse);
      }
      console.error(format("Request type {1} unknown, req {0}", JSON.stringify(req), req.type));
      return false;
    });
});