/// <reference lib="webworker" />

// importScripts('./worker-common.model');
import { WorkerMessage, WorkerAction } from './worker-common.model';

addEventListener('message', async ({ data }) => {
  if (data) {
    const theMessage = data as WorkerMessage;
    const theData = theMessage.data;
    const theAction = theMessage.action;

    let responseMessage: WorkerMessage;
    if (theAction === WorkerAction.FetchCheckpoints) {
      const tagID = +theData;
      if (typeof tagID !== 'number') {
        // throw new Error('tagID should be number');
        return postMessage(new Error('tagID should be number'));
      }
      const responseData = await fetchCheckpointsByTag(+theData);
      responseMessage = new WorkerMessage(responseData, theAction);
    } else {
      // if (action === WorkerAction.Ping)
      const content = (theData || '').split('').sort().join('');
      responseMessage = new WorkerMessage(content, theAction);
    }
    return postMessage(responseMessage);
  } else {
    console.error('data of MessageEvent is empty');
  }
});

/// localStorage is not available in web worker
// https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Functions_and_classes_available_to_workers
/** caching */
const __STORAGE__ = new Map<string, any>();

/** generate key for localStorage */
const genStorageKey = (...parameters) => {
  // arguments.callee is also not availabe in web worker
  return (parameters || []).join(':');
};

const fetchCheckpointsByTag = async (tagID?: number) => {
  const checkpoints = await fetchCheckpoints();
  if (tagID) {
    const checkpointIDs = (await fetchCheckpointTagMap()).filter(_ => _.TagID === tagID).map(_ => _.CheckPointID);
    const hashMap = new Set(checkpointIDs);
    return checkpoints.filter(_ => hashMap.has(_.ID));
  } else {
    return checkpoints;
  }
};

type CheckPoint = { ID: number, Title: string };

/** function to fetch checkpoints */
const fetchCheckpoints = async () => {
  const storeKey = genStorageKey(fetchCheckpoints.name);
  let checkpoints: Array<CheckPoint> = __STORAGE__.get(storeKey);
  if (!(Array.isArray(checkpoints) && checkpoints.length)) {
    // no data stored in localStorage
    const resp = await fetch('http://localhost:44316/api/CheckPoints', {
      method: 'POST',
      credentials: 'include'
    });
    checkpoints = await resp.json();
    __STORAGE__.set(storeKey, checkpoints);
  }
  return checkpoints || [];
};

type CheckPoint_Tag_Map = { CheckPointID: number, TagID: number };
const fetchCheckpointTagMap = async () => {
  const storeKey = genStorageKey(fetchCheckpointTagMap.name);
  let checkpointTagMap: Array<CheckPoint_Tag_Map> = __STORAGE__.get(storeKey);
  if (!(Array.isArray(checkpointTagMap) && checkpointTagMap.length)) {
    const resp = await fetch('http://localhost:44316/api/CheckPointTagMap', {
      method: 'POST',
      credentials: 'include'
    });
    checkpointTagMap = await resp.json();
    __STORAGE__.set(storeKey, checkpointTagMap);
  }
  return checkpointTagMap || [];
};

/** enumerator for all worker actions */
export enum WorkerAction {
    Ping,
    FetchCheckpoints
}

export enum WorkerStatusCode {
    Initial,
    OK,
    Error,
    Empty,
    ToBeContinued
}

export class WorkerMessage {
    constructor(
        public data: any,
        public action: WorkerAction
    ) {

    }
    public status?: WorkerStatusCode = WorkerStatusCode.Initial;
}

ngOnInit(): void {
  // register web worker
  if (typeof Worker !== 'undefined') {
    this.webWorker = new Worker('../xxxx.worker', { type: 'module' });
    this.webWorker.addEventListener('message', ({ data }) => {
      const theMessage = data as WorkerMessage;
      const theAction = theMessage.action;
      if (theAction === WorkerAction.FetchCheckpoints) {
        this.qwCheckPoints.response.Data = theMessage.data || [];
        this.qwCheckPoints.status = Utility.isNotEmptyArray(this.qwCheckPoints.response.Data) ?
          QueryStatus.SUCCESS : QueryStatus.EMPTY;
      }
    });
    this.webWorker.postMessage(new WorkerMessage(null, WorkerAction.FetchCheckpoints));
  } else {
    // Web workers are not supported in this environment.
    // TODO: You should add a fallback so that your program still executes correctly.
    console.log('The browser doesn\'t support Web Worker.');
  }
}

someAction(tce) {
  const tagID = tce.index === 0 ? 0 : (this.qwCheckPointTags.response.Data[tce.index - 1] || {}).ID;
  // this.qwCheckPoints.query(tagID);
  this.webWorker.postMessage(new WorkerMessage(tagID, WorkerAction.FetchCheckpoints));
}