// server.js

const { MongoClient } = require('mongodb');

let db;
const url = 'MongoDB 데이터베이스랑 연결할 수 있는 url';
new MongoClient(url).connect().then((client)=>{
  console.log('DB 연결 성공');
  // client가 url에 접속해서 연결했다면 db연결이 성공한 거다
  db = client.db('forum'); // forum이라는 DB에 접속
    
  // 보통은 db가 연결한 후에 포트를 연다 (listen)
  // 따라서 connect().then 이후에 listen 작업
  app.listen(8080, () => {
    console.log("http://localhost:8080 에서 서버가 실행 중입니다.");
  });
}).catch((err)=>{
  console.log(err);
});

app.get('/post', (요청, 응답) => {
    // db.collection('저장을원하는콜렉션이름').insertOne({정보들});
    // == 저장을 원하는 콜렉션에 정보들을 하나 넣는다 
    db.collection('post').insertOne({sample : 'sample'});
    // sample : 'sample'이라는 document를 post라는 collection에 넣는다
});

// 위의 기능 : /post라는 세부 페이지에 입장하면
// db.collection 중 post라는 collection에
// sample : 'sample'이라는 document를 추가해라

app.get('/list', async (요청, 응답) => {
    // 응답.send('db에 있던 게시물');
    // db.collection('출력을원하는콜렉션이름').find().toArray();
    // == 특정 콜렉션의 document들을 전부 찾아서 배열 형태로 반환 (async, await 필요)

    // await : 다음 줄을 실행할 때까지 기다리기 (non-blocking i/o이기 때문에 처리가 오래걸리는 코드는 처리완료를 기다리지 않고 바로 다음 줄을 시행하기 때문에)
    // 따라서 db에 있는 자료를 모으기 위하거나 찾기 위해서는 프로그램이 잠깐은 기다려야 한다
    // await 말고도 콜백이나 then 써서 사용할 수는 있으나 mongo에서 계속 await 쓰라니깐 그렇게 한다
    let postlist = await db.collection('post').find().toArray();
    // 그러면 [{}, {}, ...] 이런 형식으로 list에 저장이 된 것이다
    console.log(postlist);

    // ejs 파일을 사용자에게 보내야함
    // 응답.render('ejs 파일명') 
    응답.render('list.ejs', {글목록 : postlist});
});

// express 라이브러리를 사용하겠다는 뜻
// 앞으로 app.~~~ 이렇게 사용할 예정
const express = require('express');
const app = express();

// static 등록
app.use(express.static(__dirname + '/public'));

// app.listen : 컴퓨터에 port를 뚫어놓는 코드
// 첫번째 인자 : port 번호 
// 두번째 인자 : 함수
app.listen(8080, () => {
    console.log('http://localhost:8080 에서 서버 실행중');
});

// app.get : 어떤 페이지 들어가면 어떤 걸 해준다
// 첫번째 인자 : 페이지의 경로 ('/' : 메인 페이지)
// 두번째 인자 : 어떤 페이지에 접속했을 때 실행할 함수 
app.get('/', (요청, 응답) => {
  응답.send('메인 페이지');
});

app.get('/about', (요청, 응답) => {
    응답.sendFile(__dirname + '/about.html');
});

app.get('/list', async (요청, 응답) => {
    // 글 보여줄 글목록을 db로부터 가지고 오기
    let postlist = await db.collection('post').find().toArray();
    console.log(postlist);

    // ejs 띄우기
    응답.render('list.ejs', {글목록 : postlist});
});

app.get('/detail/:id', async(요청, 응답) => {
  try {
    let posting = await db.collection('post').findOne({_id : new ObjectId(요청.params.id)});
    console.log(요청.params.id); 

    if (posting != null) { // 만약 posting이 null이 아니면
      응답.render('detail.ejs', {글 : posting});
    }

    else { // posting이 null이면
      응답.send("<script>alert('존재하지 않는 게시물입니다.'); window.location.replace('/list');</script>");
    }
  } catch (err) {
    console.log('error occurred');
    return 응답.status(404).send('user error occurred');
    // 404는 유저잘못이라는 뜻임
  }
});

app.get('/write', async(요청, 응답) => {
    응답.render('write.ejs');
});

app.post('/add', async(요청, 응답) => {
    // 요청.body : 유저가 보낸 데이터를 출력 가능 
    // -> body 사용하려면 기본 세팅 필요
    // 요청.query : 유저가 보낸 URL query 데이터를 출력 가능 (query string)
    console.log(요청.body)

    // 예외 처리 (검열처리) => if/else문
    // 만약 제목이나 내용이 없다면 다시 작성하게끔 하기
    if (요청.body.title == '' || 요청.body.content == '') {
      // 다시 작성하라는 메세지와 함께 작성창 다시 로드하기
      응답.send("<script>alert('제목이나 내용이 없습니다. 다시 작성해주십시오.'); window.location.replace('/write');</script>");
    }

    else {
      // 만약에 db가 다운되거나 db가 용량이 딸릴때는 저장하면 안되지 않을까?
      // 에러상황 처리는 try, catch
      try {
        await db.collection('post').insertOne({
          title : 요청.body.title, // 제목 넣기
          content : 요청.body.content // 내용 넣기
        });
        // 다른 페이지로 이동시키기 : 응답.redirect
        응답.redirect ('/list');
      } catch (err) {
        console.log(err); // 에러 출력하기
        return 응답.status(500).send('server error occurred');
        // 500은 서버잘못으로 인한 에러라는 뜻임
      }
    }
});

// server.js

// /list 페이지 : 글 목록을 보여준다. (page 파라미터에 따라 게시물을 5개씩 보여줌)
app.get('/list/:page', async (요청, 응답) => {
  // 현재 페이지에 해당되는 5개 이하의 게시물을 postlist에 저장
  let postlist = await db.collection('post').find().skip((요청.params.page-1) * 5).limit(5).toArray();
  let allPostlist = await db.collection('post').find().toArray();
  console.log(postlist, Number(allPostlist.length));

  응답.render('list.ejs', {글목록 : postlist, 페이지 : 요청.params.page, 글수 : allPostlist.length});
});

// server.js
app.get('/edit', async(요청, 응답) => {
    let posting = await db.collection('post').findOne({_id : new ObjectId(요청.query.id)});
    console.log(요청.query.id); 
    
    응답.render('edit.ejs', {글 : posting});
});

// 서버에 없는 정보일 때 대처 : 유저에게 보내라고 하거나 or db에서 읽거나
app.put('/edit', async(요청, 응답) => {
  console.log (요청.body);
  try {
    if (요청.body.title == '' || 요청.body.content == '') {
      응답.send("<script>alert('제목이나 내용이 존재하지 않습니다.');</script>");
    } 
    else {
      await db.collection('post').updateOne({_id : new ObjectId(요청.body.id) }, {$set : {title : 요청.body.title, content : 요청.body.content}});
      응답.redirect('/list');
    }
  } catch (err) {
    응답.status(500).send('server error occurred');
  }
});

// server.js

app.delete('/delete', async(요청, 응답) => {
  let posting = await db.collection('post').findOne({_id : new ObjectId(요청.query.id)});

  console.log(posting)

  if (posting != null) {
    const confirmDelete = true;

    if (confirmDelete == true) {
      await db.collection('post').deleteOne({_id : new ObjectId(요청.query.id)});
      응답.send("<script>alert('삭제되었습니다.');</script>");
    }

    else {
      응답.redirect('/detail/' + 요청.query.id);
    }
  }

  else {
    응답.send("<script>alert('해당하는 게시물이 없습니다.'); window.location.replace('/list');</script>");
  }
});

// /login 페이지에 사용할 DB 탐색 함수 (passport)
// 사용 방식 : passport.authenticate('local')(~~~~~~~~)
passport.use(new LocalStrategy(async (입력아이디, 입력비밀번호, cb) => {
  try {
    let result = await db.collection('user').findOne({ username : 입력아이디});

    if (!result) {
      return cb(null, false, { message: 'DB에 account가 없음' });
    }

    // 해싱된 비밀번호와 입력한 비밀번호를 비교
    let isPassword = await bcrypt.compare(입력비밀번호, result.password);
    console.log(isPassword);

    if (isPassword) {
      return cb(null, result);
    } 
    
    else {
      return cb(null, false, { message: '비밀번호 불일치' });
  } } catch (err) {
    return 응답.status(500).send('DB error occurred');
  }
}));

// login 완료 후 session 발행
// 요청.logIn 사용할 때 자동 실행된다
// done 안에 두번째 인자 : session document, 쿠키에 담아서 유저에게 보내줌
passport.serializeUser((user, done) => {
  process.nextTick(() => {
    done(null, { id: user._id, username: user.username });
  });
});

// deserializeUser : 유저가 보낸 쿠키 분석 & session과 비교 (요청.user == 유저의 정보)
// 회원가입과 로그인 페이지 API를 맨 위로 보내기
passport.deserializeUser(async(user, done) => {
  let result = await db.collection('user').findOne({_id : new ObjectId(user.id)})
  delete result.password
  process.nextTick(() => {
    return done(null, result)
  })
});

// /login : 로그인 페이지
app.get ('/login', (요청, 응답) => {
  응답.render("login.ejs", {로그인상태 : 요청.user});
});

app.post ('/login', async(요청, 응답, next)=> {
  // 제출한 아이디와 비번 쌍이 DB에 있는 건지 확인
  // -> session 생성

  // 아래 과정은 base. passport 문법으로 구현
  // const user = await db.collection('user').findOne({
  //   username : 요청.body.username,
  //   password : 요청.body.password
  // });
  // if (user == null) {
  //   console.log("이런 회원 없음");
  // }
  // else {
  //   console.log("회원가입 성공");
  // }

  passport.authenticate('local', {sessions: false}, (error, user, info) => {
    if (error) { // 서버 에러남
      return 응답.status(500).send ("server error occured");
    }

    if (!user) { // 유저가 없음 or 비밀번호 불일치
      return 응답.status(401).json (info.message);
    }

    요청.logIn(user, (err) => { // logIn함수가 session을 만들어 준다
      if (err) { // 에러나면
        return next(err);
      }

      응답.redirect("/");
    });
  })(요청, 응답, next);
});

// /register : 회원가입
app.get ('/register', async(요청, 응답) => {
  응답.render ("register.ejs", {로그인상태 : 요청.user});
});

app.post ('/register', async(요청, 응답) => {
  if (요청.body.username == '' || 요청.body.password == '') {
    응답.send("<script>alert('아이디나 비밀번호가 작성되지 않았습니다. 다시 작성해주십시오.'); window.location.replace('/auth');</script>");
  }

  else {
    try {
      // 비밀번호를 hashing해서 저장하기
      let hashingPassword = await bcrypt.hash(요청.body.password, 10);

      await db.collection('user').insertOne({
        username : 요청.body.username, // 아이디 넣기
        password : hashingPassword, // 비밀번호 넣기 (해싱된)
        name : 요청.body.name // 이름 넣기
      });

      응답.redirect ('/');
    } catch (err) {
      console.log(err);
      return 응답.status(500).send('server error occurred');
    }
  }
});