import { LisioBooleanParameterNames, LisioNumericParameterNames, LisioStringParameterNames } from "@lisio/lisio-profils";
import UserControllerStorageSite from "../controllers/storages/user-controller-storage-site";
import UserControllerStorageExt from "../controllers/storages/user-controller-storage-ext";

const userStorage = __BUILD_TARGET__ === "extension" ? new UserControllerStorageExt() : new UserControllerStorageSite();

// Every action handled by processStorageMessage. The switch below is typed against this list,
// so a case label missing from it fails type-checking.
const HANDLED_ACTIONS = [
  "has-current-user",
  "get-users-size",
  "need-to-be-deleted",
  "delete-user",
  "rename-user",
  "delete-all-user",
  "switch-user",
  "disable-all-book-page-reading",
  "get-all-users",
  "get-usernames",
  "get-next-user-number",
  "get-selected-user",
  "update-user-number",
  "update-user-boolean",
  "update-user-string",
  "synchronize-from-query",
  "check-storage-version",
  "set-is-popin-hidden",
  "set-is-process-end",
  "get-current-user",
  "create-new-user",
] as const;

type StorageWorkerAction = typeof HANDLED_ACTIONS[number];

const HANDLED_ACTIONS_SET: ReadonlySet<string> = new Set(HANDLED_ACTIONS);

type StorageWorkerRequest = {
  id: number;
  type: "request";
  action: StorageWorkerAction;
  payload: string;
};

function isStorageWorkerRequest(message: unknown): message is StorageWorkerRequest {
  if (message == undefined || typeof message !== "object") {
    return false;
  }
  const { type, action, id } = message as Record<string, unknown>;
  return type === "request" && typeof action === "string" && HANDLED_ACTIONS_SET.has(action) && id != undefined;
}

async function processStorageMessage(message: StorageWorkerRequest){
  const { id, type, action, payload } = message;
  if (type === "request") {
    let result: any = {};

    switch (action) {
      case "has-current-user":{
        result = userStorage.currentUser != undefined ;
        break;
      }
      case "get-users-size":{
        result = userStorage.users.size;
        break;
      }
      case "need-to-be-deleted":{
        result = {username: "", hasBeenDeleted: false, usersSize : 0};
        if(userStorage.currentUser != undefined){
          (result as {username: string}).username = userStorage.currentUser.name;
        }
        const hasBeenDeleted = await userStorage.checkIfUserNeedToBeDeleted();
        (result as {hasBeenDeleted: boolean}).hasBeenDeleted = hasBeenDeleted;
        (result as {usersSize: number}).usersSize = userStorage.users.size;
        break;
      }
      case "delete-user":{
        const {username} = JSON.parse(payload) as {username: string};
        await userStorage.deleteUser(username);
        result = {};
        break;
      }
      case "rename-user":{
        const {newUsername} = JSON.parse(payload) as {newUsername: string};
        result = await userStorage.renameUser(newUsername);
        break;
      }
      case "delete-all-user":{
        await userStorage.deleteAllUsers();
        result = {};
        break;
      }
      case "switch-user":{
        const {nextUsername} = JSON.parse(payload) as {nextUsername: string};
        result = await userStorage.switchSelectedUser(nextUsername);
        break;
      }
      case "disable-all-book-page-reading":{
        result = await userStorage.disableAllBookPageOrReading();
        break;
      }
      case "get-all-users":{
        await userStorage.getAllUsers();
        result = [...userStorage.users.values()].map(user=>user.formatForSaving());
        break;
      }
      case "get-usernames":{
        await userStorage.getAllUsers();
        result = userStorage.usernames;
        break;
      }
      case "get-next-user-number":{
        await userStorage.getNextUserNumber();
        result = userStorage.nextUserNumber;
        break;
      }
      case "get-selected-user":{
        await userStorage.getSelectedUser();
        result = userStorage.currentUser?.formatForSaving();
        break;
      }
      case "update-user-number":{
        const {name, value, isDefault} = JSON.parse(payload) as {name: LisioNumericParameterNames, value: number, isDefault: boolean};
        await userStorage.updateUserNumber(name, value, isDefault);
        result = {};
        break;
      }
      case "update-user-boolean":{
        const {name, value} = JSON.parse(payload) as {name: LisioBooleanParameterNames, value: boolean, isDefault: boolean};
        await userStorage.updateUserBoolean(name, value);
        result = {};
        break;
      }
      case "update-user-string":{
        const {name, value, isDefault} = JSON.parse(payload) as {name: LisioStringParameterNames, value: string, isDefault: boolean};
        await userStorage.updateUserString(name, value, isDefault);
        result = {};
        break;
      }
      case "synchronize-from-query":{
        const { urlQueries } = JSON.parse(payload) as {urlQueries: string[]};
        result = await userStorage.synchronizeFromUrlQuery(urlQueries);
        break;
      }
      case "check-storage-version":{
        for(const storageController of userStorage.storageControllers){
          await storageController.checkStorageVersion();
        }
        break;
      }
      case "set-is-popin-hidden":{
        const { value } = JSON.parse(payload) as {value: boolean};
        for (const storageController of userStorage.storageControllers) {
          await storageController.setIsPopinHidden(value);
        }
        break;
      }
      case "set-is-process-end":{
        const { value } = JSON.parse(payload) as {value: boolean};
        for (const storageController of userStorage.storageControllers) {
          await storageController.setIsProcessEnd(value);
        }
        break;
      }
      case "get-current-user":{
        result = userStorage.currentUser?.formatForSaving();
        break;
      }
      case "create-new-user":{
        result = await userStorage.createNewUser();
        break;
      }
      default:
        result = { error: "Unknown action" };
    }
    return { id, type: "response", result: result};
  }
}

export { processStorageMessage, isStorageWorkerRequest };
export type { StorageWorkerRequest, StorageWorkerAction };
