// 붉은 점이 얼굴에 보일 때 수두 환자일 확률은 어떻게 구할까?
P(수두 | 붉은점) = P(붉은 점 | 수두) * P(수두) / P(붉은점)

function insertionSort(unsortedList) {
  const len = unsortedList.length;
  for (let i = 1; i < len; i++) {
    // Copy of the current element.
    const tmp = unsortedList[i];
    // Check through the sorted part and compare with the number in tmp. If large, shift the number
    for (var j = i - 1; j >= 0 && unsortedList[j] > tmp; j--) {
      // Shift the number
      unsortedList[j + 1] = unsortedList[j];
    }
    // Insert the copied number at the correct position
    // in sorted part.
    unsortedList[j + 1] = tmp;
  }
}

function selectionSort(items) {
  const length = items.length;
  for (let i = 0; i < length - 1; i++) {
    // Number of passes
    // min holds the current minimum number position for each pass; i holds the Initial min number
    let min = i;
    // Note that j = i + 1 as we only need to go through unsorted array
    for (let j = i + 1; j < length; j++) {
      // Compare the numbers
      if (items[j] < items[min]) {
        // Change the current min number position if a smaller num is found
        min = j;
      }
    }
    if (min != i) {
      // After each pass, if the current min num != initial min num, exchange the position.
      // Swap the numbers
      const tmp = items[i];
      items[i] = items[min];
      items[min] = tmp;
    }
  }
}

const quickSort = (list) => {
  if (list.length < 2) {
    return list;
  }

  const pivot = list[0];
  // const pivot = list[Math.floor(list.length / 2)];
  const smaller = list.filter((item) => item < pivot);
  const bigger = list.filter((item) => item > pivot);

  return [...quickSort(smaller), pivot, ...quickSort(bigger)];
};

function LinkedList() {
  this.head = null;
}

LinkedList.prototype.push = function (val) {
  const node = {
    value: val,
    next: null,
  };

  if (!this.head) {
    this.head = node;
  } else {
    current = this.head;
    while (current.next) {
      current = current.next;
    }
    current.next = node;
  }
};

const sll = new LinkedList();
sll.push(2);
sll.push(3);
sll.push(4);

// check values by traversing LinkedList
sll.head; // Object {data: 2, next: Object}
sll.head.next; // Object {data: 3, next: Object}
sll.head.next.next; // Object {data: 4, next: null}

// Implement a Graph
// basic operations:
//  - add vertex (node)
//  - add edge (node -> node)

function GraphNode(val) {
  this.val = val;
  this.edges = {};
}

function Graph() {
  this.vertices = {};
}

// O(1) operation
Graph.prototype.addVertex = function (val) {
  // add vertex only if it does not exist.
  if (!this.vertices[val]) {
    this.vertices[val] = new GraphNode(val);
  }
};

// O(E) operation - edges
Graph.prototype.removeVertex = function (val) {
  if (this.vertices[val]) {
    // once you remove a vertex, you need to remove all edges pointing
    // to the vertex.
    delete this.vertices[val];

    Object.keys(this.vertices).forEach(
      function (key, index) {
        if (this.vertices[key].edges[val]) {
          delete this.vertices[key].edges[val];
        }
      }.bind(this),
    );
  }
};

// O(1) operation
Graph.prototype.getVertex = function (val) {
  return this.vertices[val];
};

// O(1) operation
Graph.prototype.addEdge = function (start, end) {
  // check to see if vertices exists.
  // if it exists, set the edges and be done.
  if (this.vertices[start] && this.vertices[end]) {
    // check to see if edge exists, if it does, increment it's weight
    if (this.vertices[start].edges[end]) {
      this.vertices[start].edges[end].weight += 1;
    } else {
      // edge does not exist, set weight to 1.
      this.vertices[start].edges[end] = { weight: 1 };
    }
  }
};

// O(1) operation
Graph.prototype.removeEdge = function (start, end) {
  if (this.vertices[start] && this.vertices[end]) {
    if (this.vertices[start].edges[end]) {
      delete this.vertices[start].edges[end];
    }
  }
};

// O(1) operation
Graph.prototype.getEdge = function (start, end) {
  return this.vertices[start].edges[end] || null;
};

Graph.prototype.neighbors = function (val) {
  return this.vertices[val] ? this.vertices[val].edges : null;
};

const graph = new Graph();

graph.addVertex(5);
graph.addVertex(2);
graph.addVertex(6);
graph.addVertex(7);
graph.addEdge(2, 5);
graph.addEdge(6, 7);
graph.addEdge(7, 5);
console.log(graph.getEdge(2, 5));
console.log(graph.getEdge(6, 7));
graph.removeVertex(5);
console.log(graph.getEdge(2, 5));
console.log(graph.neighbors(6));
console.log(graph.neighbors(5));

module.exports = {
  apps: [
    {
      name: "server",
      script: "server.js",
      env_production: {
        NODE_ENV: "production",
      },
      watch: true,
      ignore_watch: ["node_modules", ".git", "yarn.lock", "package-lock.json"],
      exec_mode: "cluster",
      instances: "max",
    },
  ],
};

const emojiRegex = require("emoji-regex");

// const regex = emojiRegex()
const textWithEmoji = "thumbs up👍👍";
const text = textWithEmoji.replace(emojiRegex(), "");

// text => thumbs up

// navigator (브라우저)에 serviceWorker 기능이 있는지 확인
if ("serviceWorker" in navigator) {
  // 서비스워커 설치시 DOM 블로킹을 막아준다.
  window.addEventListener("load", function () {
    // 서비스워커를 register 하면 promise를 반환한다.
    navigator.serviceWorker
      .register("/sw.js")
      .then(() => {
        console.log("서비스 워커가 등록되었다.");
      })
      .catch((error) => {
        console.log(error);
      });
  });
}

const PRE_CACHE_NAME = "캐시-스토리지1";
// 캐시하고 싶은 리소스
const urlsToCache = [
  "/public/image/image1.png",
  "/public/css/font-awesome.min.css",
];

// 서비스워커가 설치될 때
self.addEventListener("install", (event) => {
  // 캐시 등록 이벤트가 끝날 때까지 기다려
  event.waitUntil(
    // '캐시-스토리지1'을 연다.
    // @return {Promise} 연결된 Cache Database를 반환한다.
    caches
      .open(PRE_CACHE_NAME)
      .then((cache) => {
        console.log("캐시 디비와 연결됨");
        // addAll 메소드로 내가 캐싱할 리소스를 다 넣어주자.
        return cache.addAll(urlsToCache);
      })
      .then(() => {
        // 설치 후에 바로 활성화 단계로 들어갈 수 있게 해준다.
        return self.skipWaiting();
      }),
  );
});

const DYNAMIC_CACHE_NAME = "다이나믹-캐시-스토리지1";

// fetch event는 어딘가에서 리소스를 가져올 때 모두 실행된다.
// js를 가져오거나 이미지를 가져오거나 페이지를 가져오거나 등등
self.addEventListener("fetch", (event) => {
  event.respondWith(
    caches.match(event.request).then((response) => {
      // 캐시에 있으면 repsonse를 그대로 돌려준다.
      if (response) {
        return response;
      }

      // 여기서 request를 복사해준다.
      // request는 스트림으로 fetch 당 한 번만 사용해야하기 때문이다.
      // 근데 event.request로 받아도 실행은 된다
      const fetchRequest = event.request.clone();

      // if (response) return response 구문을 하나로 합칠 수도 있다.
      // return response || fetch(fetchRequest)
      return fetch(fetchRequest).then((response) => {
        // 응답이 제대로 왔는지 체크한다.
        // 구글 문서에는 다음과 같이 처리하라고 되어있는데
        // 이 경우 Cross Site Request에 대해 캐싱 처리를 할 수가 없다.
        // if(!response || response.status !== 200 || response.type !== 'basic') {
        if (!response) {
          return response;
        }

        // 응답은 꼭 복사 해줘야한다.
        const responseToCache = response.clone();

        // 캐시 스토리지를 열고 정말 캐싱을 해준다.
        caches.open(DYNAMIC_CACHE_NAME).then((cache) => {
          cache.put(event.request, responseToCache);
        });

        // 여기서 response를 내보내줘야 캐싱 처리 후에 리소스를 반환한다.
        return response;
      });
    }),
  );
});

// 서비스 워커가 활성화 될 때
self.addEventListener("activate", (event) => {
  // 영구적으로 가져갈 캐시 스트리지 화이트리스트
  const cacheWhiteList = [PRE_CACHE_NAME, DYNAMIC_CACHE_NAME];

  event.waitUntil(
    // 캐시 스토리지의 모든 스토리지명을 가져온다.
    caches.keys().then((cacheNames) => {
      // 캐시를 삭제하는 건 Promise를 반환하므로 Promise.all을 사용해 끝날 시점을 잡아야한다.
      return Promise.all(
        // 이 결과는 [Promise, Promise...] 형태가 되시겠다.
        cacheNames.map((cacheName) => {
          // 각각의 캐시 스토리지명이 화이트 리스트와 같지 않을 경우
          if (cacheWhitelist.indexOf(cacheName) === -1) {
            // 캐시를 삭제하는 Promise를 배열에 추가한다.
            return caches.delete(cacheName);
          }
        }),
      );
    }),
  );

  // activate 시에는 clients claim 메소드를 호출해서
  // 브라우저에 대한 제어권을 가져와야한다.
  return self.clients.claim();
});

self.addEventListener("fetch", (event) => {
  event.respondWith(
    caches
      .match(event.request)
      .then((response) => {
        // ...
      })
      .catch((error) => {
        // 에러 발생시 캐시되어있는 offline.html로 이동시킨다.
        return caches.open(CACHE_NAME).then((cache) => {
          // 들어온 요청의 Accept 헤더가 text/html 을 포함하고 있다면 (페이지 요청이라면)
          if (event.request.headers.get("accept").includes("text/html")) {
            // 캐시된 offline fallback 페이지를 보여준다.
            return cache.match("/offline.html");
          }
        });
      }),
  );
});

(() => {
  const STATIC_CACHE_NAME = "STATIC_CACHE_VERSION_1";
  const DYNAMIC_CACHE_NAME = "DYNAMIC_CACHE_VERSION_1";

  const WEB_CACHE = {
    init() {
      self.addEventListener("install", this.staticCacheStrategy.bind(this));
      self.addEventListener("activate", this.deleteOldCache.bind(this));
      self.addEventListener("fetch", this.dynamicCacheStrategy.bind(this));
    },

    staticCacheStrategy(event) {
      // 스태틱 캐싱
    },

    deleteOldCache(event) {
      // 캐시 삭제
    },

    dynamicCacheStrategy(event) {
      // 다이나믹 캐싱
    },
  };

  WEB_CACHE.init();
})();

const dynamicCacheStrategy = (event) => {
  // 캐싱 처리하고 싶은 content-type
  const cacheContentsTypes = [
    "image/png",
    "image/gif",
    "image/jpeg",
    "application/font-woff",
  ];

  event.respondWith(
    caches.match(event.request).then((response) => {
      const fetchRequest = event.request.clone();

      return (
        response ||
        fetch(fetchRequest)
          .then((response) => {
            if (!response) {
              return response;
            }

            // response header에서 content-type을 가져와 비교한다.
            // 아니면 request.url이 캐싱처리를 할 외부 url인지 확인한다.
            if (
              cacheContentsTypes.indexOf(
                response.headers.get("content-type"),
              ) !== -1 ||
              event.request.url.indexOf("external.url") !== -1
            ) {
              caches.open(DYNAMIC_CACHE_NAME).then((cache) => {
                cache.put(event.request, response.clone());
              });
            }

            return response;
          })
          .catch((error) => console.log(error))
      );
    }),
  );
};

importScripts(
  "https://storage.googleapis.com/workbox-cdn/releases/3.2.0/workbox-sw.js",
);

workbox.precaching.precacheAndRoute([
  {
    url: "css/fonts/fontawesome/fontawesome-webfont.eot",
    revision: "674f50d287a8c48dc19ba404d20fe713",
  },
  {
    //...
  },
]);

importScripts(
  "https://storage.googleapis.com/workbox-cdn/releases/3.4.1/workbox-sw.js",
);

// importScripts 후 타이밍 차이로 인해 모듈을 못 불러오는 경우를 방지하기 위해
// 캐싱 정책 모듈 로드를 기다린다.
workbox.loadModule("workbox-strategies");

workbox.skipWaiting();
workbox.clientsClaim();

// accept 헤더에 text/html 값이 있으면 (html 페이지 요청일 경우)
// networkFirst 캐싱
workbox.routing.registerRoute((routeData) => {
  return routeData.event.request.headers.get("accept").includes("text/html");
}, workbox.strategies.networkFirst());

// imgur 요청일 경우 cacheFirst 캐싱
workbox.routing.registerRoute(
  /.*(?:imgur)\.com.*$/,
  workbox.strategies.cacheFirst(),
);

// jsdelivr 요청일 경우 stateWhileRevalidate 캐싱
workbox.routing.registerRoute(
  /.*(?:jsdelivr)\.net.*$/,
  workbox.strategies.staleWhileRevalidate(),
);

// bootcss 요청일 경우 stateWhileRevalidate 캐싱
workbox.routing.registerRoute(
  /.*(?:bootcss)\.com.*$/,
  workbox.strategies.staleWhileRevalidate(),
);

workbox.googleAnalytics.initialize();