#include "connectors/connector.h"

#include <assert.h>
#include <stdio.h>
#include <string.h>

static Connector_Master_Key key_with(uint8 value, uint32 version)
{
  Connector_Master_Key key = {.version = version};
  memset(key.key, value, sizeof(key.key));
  return key;
}

static Connector_Account account_for(
    const char *user, const char *account_id, const char *subject)
{
  Connector_Account account;
  memset(&account, 0, sizeof(account));
  strcpy(account.account_id, account_id);
  strcpy(account.user_id, user);
  strcpy(account.provider, "google");
  strcpy(account.provider_subject, subject);
  strcpy(account.email, "[email protected]");
  strcpy(account.access_token, "access-secret");
  strcpy(account.refresh_token, "refresh-secret");
  strcpy(account.scopes, "scope");
  account.expires_at = 123456;
  return account;
}

static void test_crypto(void)
{
  Connector_Master_Key key = key_with(7, 3);
  char encrypted[4096], decrypted[128];
  assert(Connector_Encrypt(&key, "highly-secret", encrypted, sizeof(encrypted)));
  assert(strcmp(encrypted, "highly-secret") != 0);
  assert(Connector_Decrypt(&key, encrypted, decrypted, sizeof(decrypted)));
  assert(!strcmp(decrypted, "highly-secret"));

  Connector_Master_Key wrong = key_with(8, 3);
  assert(!Connector_Decrypt(&wrong, encrypted, decrypted, sizeof(decrypted)));
  Connector_Master_Key wrong_version = key;
  wrong_version.version = 4;
  assert(!Connector_Decrypt(
      &wrong_version, encrypted, decrypted, sizeof(decrypted)));
  encrypted[strlen(encrypted) - 1] =
      encrypted[strlen(encrypted) - 1] == 'A' ? 'B' : 'A';
  assert(!Connector_Decrypt(&key, encrypted, decrypted, sizeof(decrypted)));
}

static void test_store(void)
{
  Connector_Master_Key key = key_with(17, 1);
  Connector_Store store;
  assert(Connector_Store_Open(&store, ":memory:", &key));

  Connector_OAuth_Start state = {0};
  strcpy(state.state, "state-1");
  strcpy(state.code_verifier, "verifier-1");
  assert(Connector_Store_Create_State(&store, "user-a", &state, 100));
  char verifier[128];
  assert(!Connector_Store_Consume_State(
      &store, "user-a", "state-1", 101, verifier, sizeof(verifier)));
  strcpy(state.state, "state-2");
  assert(Connector_Store_Create_State(&store, "user-a", &state, 200));
  assert(!Connector_Store_Consume_State(
      &store, "user-b", "state-2", 150, verifier, sizeof(verifier)));
  assert(Connector_Store_Consume_State(
      &store, "user-a", "state-2", 150, verifier, sizeof(verifier)));
  assert(!strcmp(verifier, "verifier-1"));
  assert(!Connector_Store_Consume_State(
      &store, "user-a", "state-2", 150, verifier, sizeof(verifier)));

  Connector_Account account = account_for("user-a", "google:one", "one");
  assert(Connector_Store_Save_Account(&store, &account));
  Connector_Account second = account_for("user-a", "google:two", "two");
  strcpy(second.email, "[email protected]");
  assert(Connector_Store_Save_Account(&store, &second));
  Connector_Account loaded;
  assert(Connector_Store_Get_Account(
      &store, "user-a", "google:one", &loaded));
  assert(!strcmp(loaded.access_token, "access-secret"));
  assert(!Connector_Store_Get_Account(
      &store, "user-b", "google:one", &loaded));
  assert(!Connector_Store_Delete_Account(
      &store, "user-b", "google:one"));
  assert(Connector_Store_Get_Account(
      &store, "user-a", "google:two", &loaded));
  assert(!strcmp(loaded.email, "[email protected]"));
  Dowa_Arena *list_arena = Dowa_Arena_Create(64 * 1024);
  Connector_Account_Summary *accounts = NULL;
  assert(Connector_Store_List_Accounts(
      &store, "user-a", &accounts, list_arena));
  assert(Dowa_Array_Length(accounts) == 2);
  assert(!strcmp(accounts[0].account_id, "google:one"));
  assert(!strcmp(accounts[1].account_id, "google:two"));
  Dowa_Arena_Free(list_arena);
  Dowa_Arena *query_arena = Dowa_Arena_Create(4096);
  Deita_Result_Set *ciphertext = Deita_Query_Execute(
      store.connection,
      "SELECT access_token_enc FROM connector_accounts "
      "WHERE account_id='google:one'",
      query_arena);
  assert(ciphertext && Deita_Result_Set_Next(ciphertext));
  assert(!strstr(Deita_Result_Set_Get_Text(ciphertext, 0), "access-secret"));
  Deita_Result_Set_Free(ciphertext);
  Dowa_Arena_Free(query_arena);

  assert(Connector_Store_Get_Policy(
      &store, "user-a", "gmail.send") == CONNECTOR_CONFIRM_ALWAYS);
  assert(Connector_Store_Get_Policy(
      &store, "user-a", "drive.overwrite") == CONNECTOR_CONFIRM_ALWAYS);
  assert(Connector_Store_Get_Policy(
      &store, "user-a", "drive.create") == CONNECTOR_CONFIRM_NEVER);
  assert(Connector_Store_Set_Policy(
      &store, "user-a", "gmail.send", CONNECTOR_CONFIRM_NEVER));
  assert(Connector_Store_Get_Policy(
      &store, "user-a", "gmail.send") == CONNECTOR_CONFIRM_NEVER);

  assert(Connector_Store_Create_Confirmation(
      &store, "user-a", "digest-a", "confirm-a", 300));
  assert(!Connector_Store_Consume_Confirmation(
      &store, "user-b", "digest-a", "confirm-a", 250));
  assert(!Connector_Store_Consume_Confirmation(
      &store, "user-a", "digest-b", "confirm-a", 250));
  assert(Connector_Store_Consume_Confirmation(
      &store, "user-a", "digest-a", "confirm-a", 250));
  assert(!Connector_Store_Consume_Confirmation(
      &store, "user-a", "digest-a", "confirm-a", 250));
  assert(Connector_Store_Create_Confirmation(
      &store, "user-a", "digest-c", "confirm-c", 300));
  assert(!Connector_Store_Consume_Confirmation(
      &store, "user-a", "digest-c", "confirm-c", 301));

  assert(Connector_Store_Put_Idempotent(
      &store, "user-a", "idem-1", "digest-1", 201, "{\"id\":\"x\"}"));
  int32 status = 0;
  char body[128];
  assert(Connector_Store_Get_Idempotent(
      &store, "user-a", "idem-1", "digest-1", &status, body, sizeof(body)));
  assert(status == 201 && !strcmp(body, "{\"id\":\"x\"}"));
  assert(!Connector_Store_Get_Idempotent(
      &store, "user-a", "idem-1", "digest-other",
      &status, body, sizeof(body)));
  assert(!Connector_Store_Get_Idempotent(
      &store, "user-b", "idem-1", "digest-1", &status, body, sizeof(body)));
  assert(Connector_Store_Idempotency_Conflict(
      &store, "user-a", "idem-1", "digest-other"));
  assert(!Connector_Store_Idempotency_Conflict(
      &store, "user-b", "idem-1", "digest-other"));
  assert(Connector_Store_Audit(
      &store, "user-a", "google:one", "gmail.send", "digest-1", 200));

  Connector_Store_Close(&store);
}

static void test_digest(void)
{
  Connector_Provider_Request request = {
    .method = "POST",
    .path = "/gmail/v1/users/me/messages/send",
    .content_type = "application/json",
    .body = "{\"raw\":\"abc\"}",
    .body_length = 13
  };
  char first[65], second[65], changed[65];
  assert(Connector_Request_Digest(
      "user-a", "google:one", CONNECTOR_OP_GMAIL_SEND, &request, first));
  assert(Connector_Request_Digest(
      "user-a", "google:one", CONNECTOR_OP_GMAIL_SEND, &request, second));
  request.body = "{\"raw\":\"xyz\"}";
  assert(Connector_Request_Digest(
      "user-a", "google:one", CONNECTOR_OP_GMAIL_SEND, &request, changed));
  assert(!strcmp(first, second));
  assert(strcmp(first, changed));
}

int main(void)
{
  test_crypto();
  test_store();
  test_digest();
  printf("core_store_test: ok\n");
  return 0;
}