const { className, professor, department, classTime, place, people } = req.body;
  
    try {
      await Class.create({
        className,
        professor,
        department,
        classTime,
        place,
        people,
      });
      return res.json({className, professor, department, classTime, place, people}).redirect("/")
    } catch (err) {
      console.log(err);};

module.exports.find = async (req, res) => {
  const { keyword } = req.query;
  try {
    const item = await Class.findAll({
      where: {
        [Op.or]: [
          {
            className: {
              [Op.like]: `%${keyword}%`,
            },
          },
          {
            professor: {
              [Op.like]: `%${keyword}%`,
            },
          },
        ],
      },
    });
    if (item.length === 0) {
      return res.status(401).json({ message: "일치하는 수업이 없습니다!" });
    }
    return res.json({ item });
  } catch (err) {
   ; console.log(err)
  }
};

if(req.headers.authorization){
        //Request의 header의 Authorization에서 토큰을 추출
        let header = req.headers["authorization"]
        
        //Authorization에서 'Bearer'가 포함되어 있으므로 split 사용!!
        let token = header && header.split("")[1]
        
        //유효성검사
        jwt.verify(token, process.env.ACCESS_SECRET, (err,user)=>{
            if(err) {
                res.status(404).json(err)
            }else{
                req.user = user;
                next();
            }
    })
    }else{
        res.status(401).json({error: "Auth Error"})
    }

   //class를 등록할때 token의 유효성을 검사할수 있도록 middleware 설정하기
   classRouter.route("/register").all(authToken).post(classes.register)

$(document).ready(function () {
  //프로그래스 바를 클릭
  $(".progress1").click(function (e) {
    // 변수 x는 .progress의 left값에서 클릭한 위치의 X값을 뺀다.
    // e.pageX는 화면에서 클릭한 X의 위치를 가져온다.
    var x = e.pageX - $(".progress1").offset().left;
    //변수 clickPercentage는 변수 x / .progress.너비
    clickPercentage = x / $(".progress1").width();
    //.state의 너비는 (.progress의 너비에서 변수 clickPercentage를 곱한 값);
    $(".state1").width($(".progress1").width() * clickPercentage);
    var percentage = clickPercentage * 100;
    //Math.floor() 소수점 버림, 정수를 반환하는 함수
    $("#percentage1").text(Math.floor(percentage));
  });
});

// chart
new Chart(document.getElementById("canvas"), {
  type: "line",
  data: {
    labels: ["1", "2", "3", "4", "5", "6", "7"],
    datasets: [
      {
        label: "수업 집중도",
        data: [10, 3, 30, 23, 10, 5, 50],
        borderColor: "rgba(255, 201, 14, 1)",
        fill: true,
        lineTension: 0, // 직선을 그리려면 0
      },
      {
        label: "강의평가 집중도",
        data: [1, 3, 15, 10, 25, 30, 5],
        borderColor: "skyblue",
        fill: true,
        lineTension: 0,
      },
    ],
  },
  options: {
    responsive: false, // false면 차트 크기 조정 가능
    title: {
      display: true,
      text: "수업 + 강의평가 집중도",
    },
    tooltips: {
      // 그래프에 마우스 대면 데이터 텍스트로 보여주는 툴팁
      mode: "index", // 동일한 인데스인 항목을 찾습니다.
      intersect: false, // 툴팁 모드는 마우스 위치가 요소를 교차할 때만 적용
    },
    hover: {
      mode: "nearest", // 점과 가장 가까운 거리에 있는 항목들을 가져옵니다.
      intersect: true,
    },
    scales: {
      xAxes: [
        {
          // x축
          display: true,
          scaleLabel: {
            display: true,
            labelString: "hour",
          },
        },
      ],
      yAxes: [
        {
          // y축
          display: true,
          ticks: {
            suggestedMin: 0,
          },
          scaleLabel: {
            display: true,
            labelString: "concentration",
          },
        },
      ],
    },
  },
});

// 막대 그래프
const progressReal = document.querySelector(".progressReal");
const progressLecture = document.querySelector(".progressLecture");

let realData = 80;
let lectureData = 20;

progressReal.style.width = realData;
progressReal.innerHTML = `<span>${realData}%</span>`;

progressLecture.style.width = realData;
progressLecture.innerHTML = `<span>${lectureData}%</span>`;

const passport = require("passport");
const { Strategy: LocalStrategy } = require("passport-local");

const bcrypt = require("bcrypt");

const Student = require("../models/Student");

const passportConfig = { usernameField: "id", passwordField: "pw" };

const passportVerify = async (id, pw, done) => {
  try {
    const user = await Student.findOne({ where: { id } });
    if (!user) {
      done(null, false, { message: "존재하지 않는 사용자 입니다." });
      return;
    }

    const compareResult = await bcrypt.compare(pw, user.pw);

    if (compareResult) {
      done(null, user);
      return;
    }

    done(null, false, { reason: "올바르지 않은 비밀번호 입니다." });
  } catch (error) {
    console.error(error);
    done(error);
  }
};

module.exports = () => {
  passport.use("local", new LocalStrategy(passportConfig, passportVerify));
};

module.exports.login = async (req, res) => {
  try {
    // 아까 local로 등록한 인증과정 실행
    passport.authenticate("local", (passportError, user, info) => {
      // 인증이 실패했거나 유저 데이터가 없다면 에러 발생
      if (passportError || !user) {
        res.status(400).json({ message: info });
        return;
      }
      // user데이터를 통해 로그인 진행
      req.login(user, { session: false }, (loginError) => {
        if (loginError) {
          res.send(loginError);
          return;
        }
        // 클라이언트에게 JWT생성 후 반환
        const token = jwt.sign(
          { id: user.id, name: user.name, auth: user.auth },
          process.env.ACCESS_SECRET,
          { expiresIn: "1m", issuer: "jungseok" }
        );
        const refresh = jwt.sign(
          {
            id: user.id,
            name: user.name,
            auth: user.auth,
          },
          process.env.REFRESH_SECRET,
          { expiresIn: "10m", issuer: "jungseok" }
        );
        console.log("token: ", token);
        console.log("refresh:", refresh);
        res.redirect("/main");
      });
    })(req, res);
  } catch (error) {
    console.error(error);
    next(error);
  }
};

const Sequelize = require("sequelize");
//
module.exports = class User extends Sequelize.Model {
  static init(sequelize) {
    return super.init(
      {
        q1: {
          type: Sequelize.INTEGER(20),
          allowNull: false,
        },
        q2: {
          type: Sequelize.INTEGER(20),
          allowNull: false,
        },
        q3: {
          type: Sequelize.INTEGER(20),
          allowNull: false,
        },
        q4: {
          type: Sequelize.INTEGER(20),
          allowNull: false,
        },
        q5: {
          type: Sequelize.INTEGER(20),
          allowNull: false,
        },
        q6: {
          type: Sequelize.STRING(255),
          allowNull: false,
        },
      },
      {
        sequelize,
        timestamps: false,
        underscored: false,
        modelName: "Evaluation", // 모델 이름을 설정, 노드 프로젝트에서 사용
        tableName: "Evaluation",
        paranoid: false,
        charset: "utf8", //한글을 입력하기 위한 설정
        collate: "utf8_general_ci", //한글을 입력하기 위한 설정
      }
    );
  }

  static associate(db) {
    db.Evaluation.belongsTo(db.Class, {
      foreignKey: "CevaluationId",
      sourceKey: "id",
    });
  }
};