const {searchHandle} = require('../tools/searchSql');
const {handle} = require('../tools/handle_cjs');
const codeMap = require("../map/rcodeMap");
const log = require("../logger").logger("c_solution","info");

const d_news = require("../database/d_news");
const d_product = require("../database/d_product");
const {filePathToUrl} = require("../tools/filePathTool");
const dbField = require("../map/dbField");
const typeTool = require("../tools/typeTool_cjs");

async function addReadNum(newId){
  let [err,res] = await handle(d_news.addReadNum(newId));
  if(err){
    return [err,null];
  }
  return [null,'ok'];
}

async function searchNewsByMini(type, key, p, l){
  p = p || 1;
  l = l || 10;
  let _params = {
  }
  if(type !== 'all'){
    _params.type = type;
  }
  if(key){
    _params.key = key
  }


  return await searchHandle(
    '搜索文章失败',
    d_news.searchAllNewsMini,
    _params,
    null,
    p,
    l,
  );
}


async function addArticle(article){
  let res;
  // 获取文章类型
  let [err, typeRes] = await handle(d_news.getTypeByKey(article.type));
  if(err){
    log.error(err);
    log.error(`[新增文章] 获取文章类型失败 ${err.message}`);
    return [{
      code: codeMap.ServerError,
      message: `文章类型校验失败`
    }, null];
  }
  if(typeRes.length === 0){
    log.error(`[新增文章] 文章类型不存在`);
    return [{
      code: codeMap.NotFound,
      message: `文章类型不存在`
    }, null];
  }
  let typeItem = typeRes[0];
  [err, res] = await handle(d_news.addArticle(article, typeItem.type_id));
  if(err){
    log.error(`[新增文章] 新增文章失败 ${err.message}`);
    return [{
      code: codeMap.ServerError,
      message: `服务器错误,新增文章失败`
    }, null];
  }
  return [null, res];
}

// 修改文章
async function editArticle(article){
  let res;
  // 获取文章类型
  let [err, typeRes] = await handle(d_news.getTypeByKey(article.type));
  if(err){
    log.error(err);
    log.error(`[编辑文章] 获取文章类型失败 ${err.message}`);
    return [{
      code: codeMap.ServerError,
      message: `文章类型校验失败`
    }, null];
  }
  if(typeRes.length === 0){
    log.error(`[新增文章] 文章类型不存在`);
    return [{
      code: codeMap.NotFound,
      message: `文章类型不存在`
    }, null];
  }
  let typeItem = typeRes[0];
  [err, res] = await handle(d_news.editArticle(article, typeItem.type_id));
  if(err){
    log.error(`[编辑文章] 编辑文章失败 ${err.message}`);
    return [{
      code: codeMap.ServerError,
      message: `服务器错误,新增文章失败`
    }, null];
  }
  return [null, res];
}

async function delArticle(id){
  let [err, res] = await handle(d_news.getMiniNewsById(id));
  if(err){
    log.error(`[删除文章] 获取文章失败 ${err.message}`);
    return [{
      code: codeMap.ServerError,
      message: `服务器错误,获取文章失败`
    }, null];
  }
  if(res.length === 0){
    log.error(`[删除文章] 文章不存在`);
    return [{
      code: codeMap.NotFound,
      message: `文章不存在`
    }, null];
  }
  [err, res] = await handle(d_news.delArticle(res[0].id));
  if(err){
    log.error(`[删除文章] 删除文章失败 ${err.message}`);
    return [{
      code: codeMap.ServerError,
      message: `[服务器异常] 获取文章类型失败`
    }, null];
  }
  return [null, res];
}
async function getArticleTypes(){
  [err, res] = await handle(d_news.loadTypes());
  if(err){
    log.error(`[获取文章类型] 获取文章类型 ${err.message}`);
    return [{
      code: codeMap.ServerError,
      message: `[服务器异常] 获取文章类型失败`
    }, null];
  }
  return [err, res]
}


async function editType( id, articleType)
{
  let [err,res] = await handle(d_news.getTypeByKey(articleType.type_key))
  if(err){
    return [err,null];
  }
  if(res.length){
    let nowType = res.find(item => typeTool.toNumber(item.type_id) === typeTool.toNumber(id))
    if(!nowType){
      return [
        {
          eCode:codeMap.DataRepeat,
          eMsg:`类型关键字重复`
        },null]
    }
  }
  [err,res] = await handle(d_news.editArticleType(id, articleType));
  if(err){
    return [err,null];
  }
  return [null,res];
}

async function addType( articleType)
{
  // 数据校验
  let parentType = articleType.parent_type;
  parentType = typeTool.toNumber(parentType);
  if(parentType !== dbField.db_base.newsType.solution &&
    parentType !== dbField.db_base.newsType.news){
    return [
      {
        eCode: codeMap.NotPermission,
        eMsg: `不受支持的文章父类型, 目前支持 解决方案与文章`
      }, null];
  }
  // 判断类别关键字是否重复
  let [err,res] = await handle(d_news.getTypeByKey(articleType.type_key))
  if(err){
    return [err,null];
  }
  if(res.length){
    return [
      {
        eCode:codeMap.DataRepeat,
        eMsg:`类型关键字重复`
      },null]
  }

  [err,res] = await handle(d_news.addArticleType( articleType, parentType));
  if(err){
    return [err,null];
  }
  return [null,res];
}

// 删除产品类型
async function deleteType(id) {
  let err, res;

  // 检索产品类型下是否有产品
  [err, res] = await handle(d_news.getArticleTotalByTypeId(id));
  if (err) {
    // 删除失败
    log.error('[移除文章分类] 寻找文章失败' + err.message);
    return [err, null];
  }
  if(!res[0]){
    log.warn(`未能搜索到数据`)
  }
  console.log(res)
  if (res[0].total > 0) {
    // 存在产品
    log.warn('[移除文章分类] 存在文章，无法删除');
    return [
      {
        eCode: codeMap.NotPermission,
        eMsg: `该类型下存在文章，无法删除, 请先移除对应文章`
      }, null];
  }
  [err, res] = await handle(d_news.deleteArticleType(id));
  if (err) {
    log.error('删除失败' + err.message);
    return [err, null];
  }
  return [null,res];
}
module.exports = {
  addReadNum,
  searchNewsByMini,
  addArticle,
  editArticle,
  delArticle,
  getArticleTypes,
  editType,
  addType,
  deleteType
}