var express = require('express');
var router = express.Router();
const config = require('../../config/app');
const models = require('../../models');
const common = require('./common');
const utils = require('../../libs/utils');
const { getListBuilder } = require('../../libs/pager');
const redis = require('../../libs/redis');
const { coloringData } = require('./config');

const CACHE_PREFIX = "art_v2";
// const CACHE_EXPIRES = 60; // 60s刷新一次
const CACHE_EXPIRES = 600;


// 首页路由
router.get('/', function (req, res, next) {  // 限制严格一点
  (async function () {
    let cacheKey = `${CACHE_PREFIX}_tips-tricks`;
    let htmlData = await redis.getAsync(cacheKey);
    // htmlData = null;
    if (!htmlData) {
      let data = {
        uri: req.originalUrl,
      };

      // 渲染EJS模板到内存中
      res.render('v2/tips-tricks', data, async (err, html) => {
        if (err) {
          // 如果渲染出错，调用next()传递错误
          return next(err);
        }

        // 渲染成功，存redis, 发送数据到客户端
        htmlData = html;
        try {
          await redis.set(cacheKey, htmlData, 'EX', CACHE_EXPIRES);
        } catch (e) {
          console.error(e);
        }

        res.send(htmlData);
      });

    } else {
      // 缓存命中， 直接发送缓存数据
      res.set({ 'X-From-Cache': 'true' });
      res.send(htmlData);
    }

  })().catch(next);
});


router.get('/benefit-of-coloring-pages', function (req, res, next) {
  (async function () {
    let cacheKey = `${CACHE_PREFIX}_benefit-of-coloring-pages`;
    let htmlData = await redis.getAsync(cacheKey);
    // htmlData = null;
    if (!htmlData) {
      let data = {
        uri: req.originalUrl,
      };

      // 渲染EJS模板到内存中
      res.render('v2/benefit-of-coloring-pages', data, async (err, html) => {
        if (err) {
          // 如果渲染出错，调用next()传递错误
          return next(err);
        }

        // 渲染成功，存redis, 发送数据到客户端
        htmlData = html;
        try {
          await redis.set(cacheKey, htmlData, 'EX', CACHE_EXPIRES);
        } catch (e) {
          console.error(e);
        }

        res.send(htmlData);
      });

    } else {
      // 缓存命中， 直接发送缓存数据
      res.set({ 'X-From-Cache': 'true' });
      res.send(htmlData);
    }

  })().catch(next);

});


router.get('/choose-the-right-coloring-tools', function (req, res, next) {
  (async function () {
    let cacheKey = `${CACHE_PREFIX}_choose-the-right-coloring-tools`;
    let htmlData = await redis.getAsync(cacheKey);
    // htmlData = null;
    if (!htmlData) {
      let data = {
        uri: req.originalUrl,
      };

      // 渲染EJS模板到内存中
      res.render('v2/choose-the-right-coloring-tools', data, async (err, html) => {
        if (err) {
          // 如果渲染出错，调用next()传递错误
          return next(err);
        }

        // 渲染成功，存redis, 发送数据到客户端
        htmlData = html;
        try {
          await redis.set(cacheKey, htmlData, 'EX', CACHE_EXPIRES);
        } catch (e) {
          console.error(e);
        }

        res.send(htmlData);
      });

    } else {
      // 缓存命中， 直接发送缓存数据
      res.set({ 'X-From-Cache': 'true' });
      res.send(htmlData);
    }

  })().catch(next);

});

router.get('/color-combinations-guide', function (req, res, next) {
  (async function () {
    let cacheKey = `${CACHE_PREFIX}_color-combinations-guide`;
    let htmlData = await redis.getAsync(cacheKey);
    // htmlData = null;
    if (!htmlData) {
      let data = {
        uri: req.originalUrl,
      };

      // 渲染EJS模板到内存中
      res.render('v2/color-combinations-guide', data, async (err, html) => {
        if (err) {
          // 如果渲染出错，调用next()传递错误
          return next(err);
        }

        // 渲染成功，存redis, 发送数据到客户端
        htmlData = html;
        try {
          await redis.set(cacheKey, htmlData, 'EX', CACHE_EXPIRES);
        } catch (e) {
          console.error(e);
        }

        res.send(htmlData);
      });

    } else {
      // 缓存命中， 直接发送缓存数据
      res.set({ 'X-From-Cache': 'true' });
      res.send(htmlData);
    }

  })().catch(next);

});


router.get('/coloring-techniques-for-beginners', function (req, res, next) {
  (async function () {
    let cacheKey = `${CACHE_PREFIX}_coloring-techniques-for-beginners`;
    let htmlData = await redis.getAsync(cacheKey);
    // htmlData = null;
    if (!htmlData) {
      let data = {
        uri: req.originalUrl,
      };

      // 渲染EJS模板到内存中
      res.render('v2/coloring-techniques-for-beginners', data, async (err, html) => {
        if (err) {
          // 如果渲染出错，调用next()传递错误
          return next(err);
        }

        // 渲染成功，存redis, 发送数据到客户端
        htmlData = html;
        try {
          await redis.set(cacheKey, htmlData, 'EX', CACHE_EXPIRES);
        } catch (e) {
          console.error(e);
        }

        res.send(htmlData);
      });

    } else {
      // 缓存命中， 直接发送缓存数据
      res.set({ 'X-From-Cache': 'true' });
      res.send(htmlData);
    }

  })().catch(next);

});



router.get('/how-to-display-your-coloring-masterpieces', function (req, res, next) {
  (async function () {
    let cacheKey = `${CACHE_PREFIX}_display-your-coloring-masterpieces`;
    let htmlData = await redis.getAsync(cacheKey);
    // htmlData = null;
    if (!htmlData) {
      let data = {
        uri: req.originalUrl,
      };

      // 渲染EJS模板到内存中
      res.render('v2/display-your-coloring-masterpieces', data, async (err, html) => {
        if (err) {
          // 如果渲染出错，调用next()传递错误
          return next(err);
        }

        // 渲染成功，存redis, 发送数据到客户端
        htmlData = html;
        try {
          await redis.set(cacheKey, htmlData, 'EX', CACHE_EXPIRES);
        } catch (e) {
          console.error(e);
        }

        res.send(htmlData);
      });

    } else {
      // 缓存命中， 直接发送缓存数据
      res.set({ 'X-From-Cache': 'true' });
      res.send(htmlData);
    }

  })().catch(next);

});


router.get('/how-to-color-online', function (req, res, next) {
  (async function () {
    let cacheKey = `${CACHE_PREFIX}_how-to-color-online`;
    let htmlData = await redis.getAsync(cacheKey);
    // htmlData = null;
    if (!htmlData) {
      let data = {
        uri: req.originalUrl,
      };

      // 渲染EJS模板到内存中
      res.render('v2/how-to-color-online', data, async (err, html) => {
        if (err) {
          // 如果渲染出错，调用next()传递错误
          return next(err);
        }

        // 渲染成功，存redis, 发送数据到客户端
        htmlData = html;
        try {
          await redis.set(cacheKey, htmlData, 'EX', CACHE_EXPIRES);
        } catch (e) {
          console.error(e);
        }

        res.send(htmlData);
      });

    } else {
      // 缓存命中， 直接发送缓存数据
      res.set({ 'X-From-Cache': 'true' });
      res.send(htmlData);
    }

  })().catch(next);

});

router.get('/how-to-color-mandala-coloring-page', function (req, res, next) {
  (async function () {
    let cacheKey = `${CACHE_PREFIX}_how-to-color-mandala`;
    let htmlData = await redis.getAsync(cacheKey);
    // htmlData = null;
    if (!htmlData) {
      let data = {
        uri: req.originalUrl,
      };

      // 渲染EJS模板到内存中
      res.render('v2/how-to-color-mandala', data, async (err, html) => {
        if (err) {
          // 如果渲染出错，调用next()传递错误
          return next(err);
        }

        // 渲染成功，存redis, 发送数据到客户端
        htmlData = html;
        try {
          await redis.set(cacheKey, htmlData, 'EX', CACHE_EXPIRES);
        } catch (e) {
          console.error(e);
        }

        res.send(htmlData);
      });

    } else {
      // 缓存命中， 直接发送缓存数据
      res.set({ 'X-From-Cache': 'true' });
      res.send(htmlData);
    }

  })().catch(next);

});


module.exports = router;