/** Encapsulation **/
class User {
  // 접근 제어의 경우 typescript를 사용해 구현할 수 있다. 이후 자바스크립트로 변환하면서 스코프를 이용한다고함.

  private name: string; // 현재 클래스 내에서만 사용 가능
  private age: number; // private는 getter, setter로만 접근 가능하다.
                       // this.name 등으로 접근 불가.

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  setName(name: string) { // Private 속성을 가진 name 변수의 값을 변경합니다.
    this.name = name;
  }
  getName() { // Private 속성을 가진 name 변수의 값을 조회합니다.
    return this.name;
  }
  setAge(age: number) { // Private 속성을 가진 age 변수의 값을 변경합니다.
    this.age = age;
  }
  getAge() { // Private 속성을 가진 age 변수의 값을 조회합니다.
    return this.age;
  }
}

const user = new User('임건', 28); // user 인스턴스 생성
user.setName("임꺽정");
user.setAge(26);
console.log(user.getName()); // 임꺽정
console.log(user.getAge()); // 26
// console.log(user.name); // Error: User클래스의 name 변수는 private로 설정되어 있어 바로 접근할 수 없습니다.

class Mother { // Mother 부모 클래스
  constructor(name, age, tech) { // 부모 클래스 생성자
    this.name = name;
    this.age = age;
    this.tech = tech;
  }
  getTech(){ return this.tech; } // 부모 클래스 getTech 메서드
}

class Child extends Mother{ // Mother 클래스를 상속받은 Child 자식 클래스
  constructor(name, age, tech) { // 자식 클래스 생성자
    super(name, age, tech); // 부모 클래스의 생성자를 호출
  }
}

const child = new Child("임꺽정", "28", "Node.js");
console.log(child.name); // 임꺽정
console.log(child.age); // 28
console.log(child.getTech()); // 부모 클래스의 getTech 메서드 호출: Node.js

/** Abstraction **/
interface Human {
  name: string;
  setName(name : string) : void;
  getName() : string;
}

// 인터페이스에서 상속받은 프로퍼티와 메소드는 구현하지 않을 경우 에러가 발생합니다.
class Employee implements Human{
  // Human 인터페이스의 멤버 변수 초기화
  // name: string;
  constructor(
    public name: string
  ) {  }
  
  // Human 인터페이스에서 상속받은 메소드
  // 구현부를 작성.
  setName(name : string) { this.name = name; }
  
  // Human 인터페이스에서 상속받은 메소드
  // 구현부를 작성.
  getName() { return this.name; }
}

const employee = new Employee("");
employee.setName("임건"); // Employee 클래스의 name을 변경하는 setter
console.log(employee.getName()); // Employee 클래스의 name을 조회하는 getter

/** Polymorphism **/
class Employee {
  constructor(name) { this.name = name; }

  buy() { console.log(`${this.constructor.name} 클래스의 ${this.name}님이 물건을 구매하였습니다.`); }
}

class User {
  constructor(name) { this.name = name; }

  buy() { console.log(`${this.constructor.name} 클래스의 ${this.name}님이 물건을 구매하였습니다.`); }
}

const employee1 = new Employee("이용우");
const employee2 = new Employee("김창환");
const user1 = new User("이태강");
const user2 = new User("김민수");

const polymorphismArray = [employee1, employee2, user1, user2];
// polymorphismArray에 저장되어 있는 Employee, User 인스턴스들의 buy 메소드를 호출합니다.
// 행위는 같지만 내부적으로 작동하는 코드는 다르다.
polymorphismArray.forEach((polymorphism) => polymorphism.buy());

// Employee 클래스의 이용우님이 물건을 구매하였습니다.
// Employee 클래스의 김창환님이 물건을 구매하였습니다.
// User 클래스의 이태강님이 물건을 구매하였습니다.
// User 클래스의 김민수님이 물건을 구매하였습니다.

/** SRP Before **/
class UserSettings {
  constructor(user) { // UserSettings 클래스 생성자
    this.user = user;
  }

  changeSettings(userSettings) { // 사용자의 설정을 변경하는 메소드
    if (this.verifyCredentials()) {
      //...
    }
  }

  verifyCredentials() { // 사용자의 인증을 검증하는 메소드
    //...
  }
}

/** SRP After **/
class UserAuth {
  constructor(user) { // UserAuth 클래스 생성자
    this.user = user;
  }

  verifyCredentials() { // 사용자의 인증을 검증하는 메소드
    // 인자를 받지 않음. 멤버변수 this.user를 이용할것이므로
    //...
  }
}

class UserSettings {
  constructor(user) { // UserSettings 클래스 생성자
    this.userAuth = new UserAuth(user); // UserAuth를 새로운 객체로 정의한다.
  }

  changeSettings(userSettings) { // 사용자의 설정을 변경하는 메소드
    if (this.userAuth.verifyCredentials()) { // 생성자에서 선언한 userAuth 객체의 메소드를 사용한다.
      //...
    }
  }
}

/** OCP Before **/
function calculator(nums, option) {
  let result = 0;
  for (const num of nums) {
    if (option === "add") result += num; // option이 add일 경우 덧셈 연산을 합니다.
    else if (option === "sub") result -= num; // option이 sub일 경우 뺄셈 연산을 합니다.
    // 새로운 연산(기능)을 추가 하기 위해서는 함수 내부에서 코드 수정이 필요합니다. 곱셉/ 나눗셈
    // 테스트 코드를 작성하는 경우에도 매번 추가해야만하죠.
  }
  return result;
}

console.log(calculator([2, 3, 5], "add")); // 10
console.log(calculator([5, 2, 1], "sub")); // -8

/** OCP After **/
function calculator(nums, callBackFunc) {
  // option을 CallbackFunc로 변경
  let result = 0;
  for (const num of nums) {
    result = callBackFunc(result, num); // option으로 분기하지 않고, Callback함수를 실행하도록 변경
  }
  return result;
}

const add = (a, b) => a + b; // 함수 변수를 정의합니다.
const sub = (a, b) => a - b;
const mul = (a, b) => a * b;
const div = (a, b) => a / b;
console.log(calculator([2, 3, 5], add)); // add 함수 변수를 Callback 함수로 전달합니다.
console.log(calculator([5, 2, 1], sub)); // sub 함수 변수를 Callback 함수로 전달합니다.

/** LSP Before **/
class Rectangle {
  constructor(width = 0, height = 0) { // 직사각형의 생성자
    this.width = width;
    this.height = height;
  }

  setWidth(width) { // 직사각형은 높이와 너비를 독립적으로 정의한다.
    this.width = width;
    return this;
  }

  setHeight(height) { // 직사각형은 높이와 너비를 독립적으로 정의한다.
    this.height = height;
    return this;
  }

  getArea() { // 사각형의 높이와 너비의 결과값을 조회하는 메소드
    return this.width * this.height;
  }
}

class Square extends Rectangle { // 정사각형은 직사각형을 상속받습니다.
  setWidth(width) { // 정사각형은 높이와 너비가 동일하게 정의된다.
    this.width = width;
    this.height = width;
    return this;
  }

  setHeight(height) { // 정사각형은 높이와 너비가 동일하게 정의된다.
    this.width = height;
    this.height = height;
    return this;
  }
}

const rectangleArea = new Rectangle() // 35
  .setWidth(5) // 너비 5
  .setHeight(7) // 높이 7
  .getArea(); // 5 * 7 = 35
const squareArea = new Square() // 49
  .setWidth(5) // 너비 5
  .setHeight(7) // 높이를 7로 정의하였지만, 정사각형은 높이와 너비를 동일하게 정의합니다.
  .getArea(); // 7 * 7 = 49

/** LSP After **/
// ts의 경우에는 Interface로 생성
class Shape { // Rectangle과 Square의 부모 클래스를 정의합니다.
  getArea() { // getArea는 빈 메소드로 정의
  }
}

class Rectangle extends Shape { // Rectangle은 Shape를 상속받습니다.
  constructor(width = 0, height = 0) { // 직사각형의 생성자
    super();
    this.width = width;
    this.height = height;
  }

  getArea() { // 직사각형의 높이와 너비의 결과값을 조회하는 메소드
    return this.width * this.height;
  }
}

class Square extends Shape { // Square는 Shape를 상속받습니다.
  constructor(length = 0) { // 정사각형의 생성자
    super();
    this.length = length; // 정사각형은 너비와 높이가 같이 깨문에 width와 height 대신 length를 사용합니다.
  }

  getArea() { // 정사각형의 높이와 너비의 결과값을 조회하는 메소드
    return this.length * this.length;
  }
}

const rectangleArea = new Rectangle(7, 7) // 49
  .getArea(); // 7 * 7 = 49
const squareArea = new Square(7) // 49
  .getArea(); // 7 * 7 = 49

/** ISP Before **/
interface SmartPrinter { // SmartPrinter가 사용할 수 있는 기능들을 정의한 인터페이스 
  print();

  fax();

  scan();
}

// SmartPrinter 인터페이스를 상속받은 AllInOnePrinter 클래스
class AllInOnePrinter implements SmartPrinter {
  print() { // AllInOnePrinter 클래스는 print, fax, scan 기능을 지원한다.
    // ...
  }

  fax() { // AllInOnePrinter 클래스는 print, fax, scan 기능을 지원한다.
    // ...
  }

  scan() { // AllInOnePrinter 클래스는 print, fax, scan 기능을 지원한다.
    // ...
  }
}

// SmartPrinter 인터페이스를 상속받은 EconomicPrinter 클래스
class EconomicPrinter implements SmartPrinter {
  print() { // EconomicPrinter 클래스는 print 기능만 지원한다.
    // ...
  }

  fax() { // EconomicPrinter 클래스는 fax 기능을 지원하지 않는다.
    throw new Error('팩스 기능을 지원하지 않습니다.');
  }

  scan() { // EconomicPrinter 클래스는 scan 기능을 지원하지 않는다.
    throw new Error('Scan 기능을 지원하지 않습니다.');
  }
}

/** ISP After **/
interface Printer { // print 기능을 하는 Printer 인터페이스
  print();
}

interface Fax { // fax 기능을 하는 Fax 인터페이스
  fax();
}

interface Scanner { // scan 기능을 하는 Scanner 인터페이스
  scan();
}


// AllInOnePrinter클래스는 print, fax, scan 기능을 지원하는 Printer, Fax, Scanner 인터페이스를 상속받았다.
class AllInOnePrinter implements Printer, Fax, Scanner {
  print() { // Printer 인터페이스를 상속받아 print 기능을 지원한다.
    // ...
  }

  fax() { // Fax 인터페이스를 상속받아 fax 기능을 지원한다.
    // ...
  }

  scan() { // Scanner 인터페이스를 상속받아 scan 기능을 지원한다.
    // ...
  }
}

// EconomicPrinter클래스는 print 기능을 지원하는 Printer 인터페이스를 상속받았다.
class EconomicPrinter implements Printer {
  print() { // EconomicPrinter 클래스는 print 기능만 지원한다.
    // ...
  }
}

// FacsimilePrinter클래스는 print, fax 기능을 지원하는 Printer, Fax 인터페이스를 상속받았다.
class FacsimilePrinter implements Printer, Fax {
  print() { // FacsimilePrinter 클래스는 print, fax 기능을 지원한다.
    // ...
  }

  fax() { // FacsimilePrinter 클래스는 print, fax 기능을 지원한다.
    // ...
  }
}

/** DIP Before **/
const readFile = require('fs').readFile;

class XmlFormatter {
  parseXml(content) {
    // Xml 파일을 String 형식으로 변환합니다.
  }
}

class JsonFormatter {
  parseJson(content) {
    // JSON 파일을 String 형식으로 변환합니다.
  }
}

class ReportReader {

  async read(path) {
    const fileExtension = path.split('.').pop(); // 파일 확장자 제거

    // 분기에 따른 행위가 똑같음.
    if (fileExtension === 'xml') {
      const formatter = new XmlFormatter(); // xml 파일 확장자일 경우 XmlFormatter를 사용한다.

      const text = await readFile(path, (err, data) => data);
      return formatter.parseXml(text); // xmlFormatter클래스로 파싱을 할 때 parseXml 메소드를 사용한다.

    } else if (fileExtension === 'json') {
      const formatter = new JsonFormatter(); // json 파일 확장자일 경우 JsonFormatter를 사용한다.

      const text = await readFile(path, (err, data) => data);
      return formatter.parseJson(text); // JsonFormatter클래스로 파싱을 할 때 parseJson 메소드를 사용한다.
    }
  }
}

const reader = new ReportReader();
const report = await reader.read('report.xml');
// or
// const report = await reader.read('report.json');

/** DIP After **/
const readFile = require('fs').readFile;

class Formatter { // 인터페이스지만, Javascript로 구현하기 위해 클래스로 선언합니다.
  parse() {  }
}

class XmlFormatter extends Formatter {
  parse(content) {
    // Xml 파일을 String 형식으로 변환합니다.
  }
}

class JsonFormatter extends Formatter {
  parse(content) {
    // JSON 파일을 String 형식으로 변환합니다.
  }
}

class ReportReader {
  constructor(formatter) { // 생성자에서 Formatter 인터페이스를 상속받은 XmlFormatter, JsonFormatter를 전달받습니다.
    this.formatter = formatter;
  }

  async read(path) {
    const text = await readFile(path, (err, data) => data);
    return this.formatter.parse(text); // 추상화된 formatter로 데이터를 파싱합니다.
  }
}

const reader = new ReportReader(new XmlFormatter());
const report = await reader.read('report.xml');
// or
// const reader = new ReportReader(new JsonFormatter());
// const report = await reader.read('report.json');

// 1. 함수 생성
function sendMessageAll(message) {
	// 2. 메세지를 보내기 위한 로직 작성
	~~~
	~~
	~~~~
}

// 4. 소켓 연결 이벤트 핸들링
io.on("connection", (sock) => {
  socketIdMap[sock.id] = null;
  console.log("새로운 소켓이 연결됐어요!");

  sock.on("CHANGED_PAGE", (data) => {
    console.log("페이지가 바뀌었대요", data, sock.id);
    socketIdMap[sock.id] = data; // 소켓 아이디와 페이지 url을 매핑

    emitSamePageViewerCount();
  });

  sock.on("BUY", (data) => {
    const payload = {
      nickname: data.nickname,
      goodsId: data.goodsId,
      goodsName: data.goodsName,
      date: new Date().toISOString(),
    };

    console.log("클라이언트가 구매한 데이터", data, new Date());
    sock.broadcast.emit("BUY_GOODS", payload);
  });

  sock.on("disconnect", () => {
    delete socketIdMap[sock.id];
    console.log(sock.id, "연결이 끊어졌어요!");
    emitSamePageViewerCount();
  });
});

io.on("connection", (sock) => {
  const { watchChangePage, watchBuying, watchByeBye } = initSocket(sock);

  watchChangePage();

  watchBuying();

  watchByeBye();
});

// app.js

function initSocket(sock) {
  socketIdMap[sock.id] = null;
  console.log("새로운 소켓이 연결됐어요!");

  // 특정 이벤트가 전달되었는지 감지할 때 사용될 함수
  function watchEvent(event, func) {
    sock.on(event, func);
  }

  // 연결된 모든 클라이언트에 데이터를 전달하는 함수
  function notifyEveryone(event, data) {
    sock.broadcast.emit(event, data);
  }

  // 특정한 클라이언트에 데이터를 전달하는 함수
  function notifyTo(socketId, event, data) {
    io.to(socketId).emit(event, data);
  }

  // 페이지가 변경되었을 때, 같은 페이지를 본 사용자 수를 전달하는 함수
  function emitSamePageViewerCount() {
    const urls = Object.values(socketIdMap);
    const countByUrl = urls.reduce((value, url) => {
      if (!url) return value; // detail 페이지가 아닌 사용자는 제외
      return {
        ...value,
        [url]: value[url] ? value[url] + 1 : 1,
      };
    }, {});

    for (const [socketId, url] of Object.entries(socketIdMap)) {
      const count = countByUrl[url];
      notifyTo(socketId, "SAME_PAGE_VIEWER_COUNT", count);
    }
  }

  return {
    watchChangePage: () => {
      watchEvent("CHANGED_PAGE", (data) => {
        console.log("페이지가 바뀌었대요", data, sock.id);
        socketIdMap[sock.id] = data; // 소켓 아이디와 페이지 url을 매핑

        emitSamePageViewerCount();
      });
    },

    watchBuying: () => {
      watchEvent("BUY", (data) => {
        const payload = {
          nickname: data.nickname,
          goodsId: data.goodsId,
          goodsName: data.goodsName,
          date: new Date().toISOString(),
        };

        console.log("클라이언트가 구매한 데이터", data, new Date());
        notifyEveryone("BUY_GOODS", payload);
      });
    },

    watchByeBye: () => {
      watchEvent("disconnect", () => {
        delete socketIdMap[sock.id];
        console.log(sock.id, "연결이 끊어졌어요!");
        emitSamePageViewerCount();
      });
    },
  };
}

// app.js
const express = require("express");
const cookieParser = require("cookie-parser");
const { Server } = require("http"); // 1. 모듈 불러오기

const goodsRouter = require("./routes/goods.js");
const usersRouter = require("./routes/users.js");
const authRouter = require("./routes/auth.js");
const connect = require("./schemas");

const app = express();
const http = Server(app); // 2. express app을 http 서버로 감싸기

connect(); // mongoose를 연결합니다.

app.use(express.json());
app.use(express.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static("assets"));
app.use("/api", [goodsRouter, usersRouter, authRouter]);

app.get("/", (req, res) => {
  res.send("Hello World!");
});

module.exports = http;

// server.js
const http = require("./app.js")
require("./socket.js")

const port = 3000;

http.listen(port, () => {
  console.log(port, "포트로 서버가 열렸어요!");
});

// socket.js
const socketIo = require("socket.io"); // 1. 모듈 불러오기
const http = require("./app.js") // http 가져오기
const io = socketIo(http); // 3. http 객체를 Socket.io 모듈에 넘겨서 소켓 핸들러 생성

const socketIdMap = {};

// app.js

function initSocket(sock) {
  socketIdMap[sock.id] = null;
  console.log("새로운 소켓이 연결됐어요!");

  // 특정 이벤트가 전달되었는지 감지할 때 사용될 함수
  function watchEvent(event, func) {
    sock.on(event, func);
  }

  // 현재 사용자를 제외한 연결된 모든 클라이언트에 데이터를 전달하는 함수
  function notifyEveryone(event, data) {
    sock.broadcast.emit(event, data);
  }

  // 특정한 클라이언트에 데이터를 전달하는 함수
  function notifyTo(socketId, event, data) {
    io.to(socketId).emit(event, data);
  }

  // 페이지가 변경되었을 때, 같은 페이지를 본 사용자 수를 전달하는 함수
  function emitSamePageViewerCount() {
    const urls = Object.values(socketIdMap);
    const countByUrl = urls.reduce((value, url) => {
      if (!url) return value; // detail 페이지가 아닌 사용자는 제외
      return {
        ...value,
        [url]: value[url] ? value[url] + 1 : 1,
      };
    }, {});

    for (const [socketId, url] of Object.entries(socketIdMap)) {
      const count = countByUrl[url];
      notifyTo(socketId, "SAME_PAGE_VIEWER_COUNT", count); // 추상화된 notifyTo 함수 이용
    }
  }

  return {
    watchChangePage: () => {
      watchEvent("CHANGED_PAGE", (data) => {
        console.log("페이지가 바뀌었대요", data, sock.id);
        socketIdMap[sock.id] = data; // 소켓 아이디와 페이지 url을 매핑

        emitSamePageViewerCount();
      });
    },

    watchBuying: () => {
      watchEvent("BUY", (data) => {
        const payload = {
          nickname: data.nickname,
          goodsId: data.goodsId,
          goodsName: data.goodsName,
          date: new Date().toISOString(),
        };

        console.log("클라이언트가 구매한 데이터", data, new Date());
        notifyEveryone("BUY_GOODS", payload);
      });
    },

    watchByeBye: () => {
      watchEvent("disconnect", () => {
        delete socketIdMap[sock.id];
        console.log(sock.id, "연결이 끊어졌어요!");
        emitSamePageViewerCount();
      });
    },
  };
}

io.on("connection", (sock) => {
  const { watchChangePage, watchBuying, watchByeBye } = initSocket(sock);

  watchChangePage();

  watchBuying();

  watchByeBye();
});