import { Context } from 'koa';
import { InterfaceResponseData } from '@utils/response';
import { InterfaceDocument, InterfacePage, InterfaceTag, InterfaceDocumentList } from '@/controllers/document';
import { CODE, decipher, cipher, MapDocMethod } from '@/utils';

const putDocument = async (ctx: Context, params: InterfaceDocument) :Promise<InterfaceResponseData> => {
  const reData: InterfaceResponseData = {
    data: null,
    message: '',
    success: false,
    code: 400000
  };
  return new Promise(resolve => {
    ctx.$db.doc.findOne({ url: params.url }, (err, findDoc) => {
      if (err) {
        ctx.$log.error(err);
        ctx.status = 500;
        resolve(reData);
        return;
      };
      if (findDoc) {
        reData.message = 'url已存在';
        reData.code = CODE.EXIST_PARAMS;
        resolve(reData);
        return;
      };
      ctx.$db.tag.findOne({ _id: params.tag }, (err, findTag) => {
        if (err) {
          ctx.$log.error(err);
          ctx.status = 500;
          resolve(reData);
          return;
        };
        if (!findTag) {
          reData.message = '版本不存在';
          reData.code = CODE.ERR_PARAMS;
          resolve(reData);
          return;
        };
        ctx.$db.doc.insert(params, (err, saveDoc) => {
          if (err) {
            ctx.$log.error(err);
            ctx.status = 500;
            resolve(reData);
            return;
          };
          reData.data = saveDoc;
          reData.message = '保存成功';
          reData.success = true;
          reData.code = CODE.SUCCESS;
          resolve(reData);
        });
      });
    });
  });
};

const getDocument = async (ctx: Context, id: string) :Promise<InterfaceResponseData> => {
  const decodeId = decipher(id);
  const reData: InterfaceResponseData = {
    data: null,
    message: '',
    success: false,
    code: 400000
  };
  return new Promise(resolve => {
    ctx.$db.doc.findOne({ _id: decodeId }, (err, findDoc) => {
      if (err) {
        ctx.$log.error(err);
        ctx.status = 500;
        resolve(reData);
        return;
      };
      findDoc._id = id;
      findDoc.method_des = MapDocMethod[findDoc.method];
      reData.data = findDoc;
      reData.message = '成功';
      reData.success = true;
      reData.code = CODE.SUCCESS;
      resolve(reData);
    });
  });
};

const getDocumentList = async (ctx: Context, params: InterfaceDocumentList) :Promise<InterfaceResponseData> => {
  const reData: InterfaceResponseData = {
    data: null,
    message: '',
    success: false,
    code: 400000
  };
  return new Promise(resolve => {
    ctx.$db.doc.find({ tag: params._id }).sort({ url: 1 }).exec((err, docs) => {
        if (err) {
          ctx.$log.error(err);
          ctx.status = 500;
          resolve(reData);
          return;
        };
        docs.forEach(el => {
          el._id = cipher(el._id);
          el.method_des = MapDocMethod[el.method];
          console.log(MapDocMethod[el.method]);
        });
        reData.data = docs;
        reData.message = '成功';
        reData.success = true;
        reData.code = CODE.SUCCESS;
        ctx.$db.doc.count({}, (err, count) => {
          if (err) {
            ctx.$log.error(err);
            ctx.status = 500;
            resolve(reData);
            return;
          };
          reData.data.total = count;
          resolve(reData);
        });
    });
  });
};

const deleteDocument = async (ctx: Context, id: string) :Promise<InterfaceResponseData> => {
  const decodeId = decipher(id);
  const reData: InterfaceResponseData = {
    data: null,
    message: '',
    success: false,
    code: 400000
  };
  return new Promise(resolve => {
    ctx.$db.doc.remove({ _id: decodeId }, {}, (err) => {
      if (err) {
        ctx.$log.error(err);
        ctx.status = 500;
        resolve(reData);
        return;
      };
      reData.data = null;
      reData.message = '删除成功';
      reData.success = true;
      reData.code = CODE.SUCCESS;
      resolve(reData);
    });
  });
};

const updateDocument = async (ctx:Context, { _id, tag, ...params }: InterfaceDocument) :Promise<InterfaceResponseData> => {
  const decodeId = decipher(_id || '');
  const reData: InterfaceResponseData = {
    data: null,
    message: '',
    success: false,
    code: 400000
  };
  return new Promise(resolve => {
    ctx.$db.tag.findOne({ _id: tag }, (err, findTag) => {
      if (err) {
        ctx.$log.error(err);
        ctx.status = 500;
        resolve(reData);
        return;
      };
      if (!findTag) {
        reData.message = '版本不存在';
        reData.code = CODE.ERR_PARAMS;
        resolve(reData);
        return;
      };
      ctx.$db.doc.update({ _id: decodeId }, { $set: { ...params }}, {}, err => {
        if (err) {
          ctx.$log.error(err);
          ctx.status = 500;
          resolve(reData);
          return;
        };
          reData.data = null;
          reData.message = '更新成功';
          reData.success = true;
          reData.code = CODE.SUCCESS;
          resolve(reData);
      });
    });
  });
};

const putTag = async (ctx:Context, params: InterfaceTag) :Promise<InterfaceResponseData> => {
  const reData: InterfaceResponseData = {
    data: null,
    message: '',
    success: false,
    code: 400000
  };
  return new Promise(resolve => {
    ctx.$db.tag.findOne({ name: params.name }, (err, findTag) => {
      if (err) {
        ctx.$log.error(err)
        ctx.status = 500;
        resolve(reData);
        return;
      };
      if (findTag) {
        reData.message = '版本已经存在';
        reData.code = CODE.EXIST_PARAMS;
        reData.success = false;
        resolve(reData);
        return;
      };
      ctx.$db.tag.insert(params, (err, saveTag) => {
        if (err) {
          ctx.$log.error(err);
          ctx.status = 500;
          resolve(reData);
          return;
        };
        reData.data = saveTag;
        reData.message = '保存成功';
        reData.success = true;
        reData.code = CODE.SUCCESS;
        resolve(reData);
      });
    });
  });
};

const updateTag = async (ctx:Context, { _id, ...params }: InterfaceTag) :Promise<InterfaceResponseData> => {
  const reData: InterfaceResponseData = {
    data: null,
    message: '',
    success: false,
    code: 400000
  };
  return new Promise(resolve => {
    ctx.$db.tag.findOne({ _id }, (err, findTag) => {
      if (err) {
        ctx.$log.error(err);
        ctx.status = 500;
        resolve(reData);
        return;
      };
      if (!findTag) {
        reData.message = '数据不存在';
        reData.code = CODE.ERR_PARAMS;
        reData.success = false;
        resolve(reData);
        return;
      };
      ctx.$db.tag.findOne({ name: params.name }, (err, findTagName) => {
        if (err) {
          ctx.$log.error(err);
          ctx.status = 500;
          resolve(reData);
          return;
        }
        if (findTagName) {
          reData.message = '版本已经存在';
          reData.code = CODE.EXIST_PARAMS;
          reData.success = false;
          resolve(reData);
          return;
        }
        ctx.$db.tag.update({ _id }, { $set: { ...params }}, {}, err => {
          if (err) {
            ctx.$log.error(err);
            ctx.status = 500;
            resolve(reData);
            return;
          };
          reData.message = '保存成功';
          reData.success = true;
          reData.code = CODE.SUCCESS;
          resolve(reData);
        });
      })

    });
  });
};

const getTagList = async (ctx: Context, params: InterfacePage) :Promise<InterfaceResponseData> => {
  const reData: InterfaceResponseData = {
    data: null,
    message: '',
    success: false,
    code: 400000
  };
  return new Promise(resolve => {
    ctx.$db.tag.find({}).sort({ url: 1 }).skip((params.page - 1) * params.size).limit(params.size).exec((err, tags) => {
        if (err) {
          ctx.$log.error(err);
          ctx.status = 500;
          resolve(reData);
          return;
        };
        reData.data = {
          list: tags,
          page: params.page,
          size: params.size
        };
        reData.message = '成功';
        reData.success = true;
        reData.code = CODE.SUCCESS;
        ctx.$db.tag.count({}, (err, count) => {
          if (err) {
            ctx.$log.error(err);
            ctx.status = 500;
            resolve(reData);
            return;
          };
          reData.data.total = count;
          resolve(reData);
        });
    });
  });
};

const deleteTag = async (ctx: Context, id: string) :Promise<InterfaceResponseData> => {
  const reData: InterfaceResponseData = {
    data: null,
    message: '',
    success: false,
    code: 400000
  };
  return new Promise(resolve => {
    ctx.$db.tag.remove({ _id: id }, {}, (err) => {
      if (err) {
        ctx.$log.error(err);
        ctx.status = 500;
        resolve(reData);
        return;
      };
      reData.data = null;
      reData.message = '删除成功';
      reData.success = true;
      reData.code = CODE.SUCCESS;
      resolve(reData);
    });
  });
};

export default {
  putDocument,
  getDocument,
  getDocumentList,
  deleteDocument,
  updateDocument,
  putTag,
  updateTag,
  getTagList,
  deleteTag
}