import operator
import os
import re
import pandas as pd
from fastapi import APIRouter, Depends, Request, File, UploadFile
from motor.motor_asyncio import AsyncIOMotorDatabase

from utils.dingding import get_redis_alluid, send_dates
from utils.jianli import get_resume
import crud, schemas
from datetime import datetime
from core.configuration import *
from db import get_database
from db.ckdb import get_ck_db, CKDrive

from models.interview_zsgc import InterviewDo
from utils import get_time, qujian_time, Download_xlsx, send_str_mail

router = APIRouter()


# 面试查询
@router.post("/interview_find")
async def interview_find(
        request: Request,
        interview: InterviewDo = Depends(InterviewDo),
        db: CKDrive = Depends(get_ck_db),
) -> schemas.Msg:
    """ interview面试数据查询 """
    await interview.init()
    res = interview.find_interview_sql()
    sql = res['sql']
    data = await db.execute(sql)
    if not data:
        return schemas.Msg(code=-9, msg='无数据', data=None)
    return schemas.Msg(code=200, msg='ok', data=data)


# 面试_主页初筛查询
@router.post("/interview_home_find")
async def interview_find(
        request: Request,
        interview: InterviewDo = Depends(InterviewDo),
        db: CKDrive = Depends(get_ck_db),
) -> schemas.Msg:
    """ interview面试数据主页初筛查询 """
    await interview.init()
    res = interview.find_interview_home_sql()
    sql = res['sql']
    data = await db.execute(sql)
    if not data:
        return schemas.Msg(code=-9, msg='无数据', data=None)
    return schemas.Msg(code=200, msg='ok', data=data)


# 复筛查询
@router.post("/interview_screen_find")
async def interview_find(
        request: Request,
        interview: InterviewDo = Depends(InterviewDo),
        db: CKDrive = Depends(get_ck_db),
) -> schemas.Msg:
    """ interview面试数据复筛查询 """
    await interview.init()
    res = interview.find_interview_screen_sql()
    sql = res['sql']
    data = await db.execute(sql)
    if not data:
        return schemas.Msg(code=-9, msg='无数据', data=None)
    return schemas.Msg(code=200, msg='ok', data=data)


# 面试阶段查询
@router.post("/interview_exam_find")
async def interview_find(
        request: Request,
        interview: InterviewDo = Depends(InterviewDo),
        db: CKDrive = Depends(get_ck_db),
) -> schemas.Msg:
    """ interview面试数据面试阶段查询 """
    await interview.init()
    res = interview.find_interview_exam_sql()
    sql = res['sql']
    data = await db.execute(sql)
    if not data:
        return schemas.Msg(code=-9, msg='无数据', data=None)
    return schemas.Msg(code=200, msg='ok', data=data)


# offer阶段查询
@router.post("/interview_offer_find")
async def interview_find(
        request: Request,
        interview: InterviewDo = Depends(InterviewDo),
        db: CKDrive = Depends(get_ck_db),
) -> schemas.Msg:
    """ interview面试数据offer阶段查询 """
    await interview.init()
    res = interview.find_interview_offer_sql()
    sql = res['sql']
    data = await db.execute(sql)
    if not data:
        return schemas.Msg(code=-9, msg='无数据', data=None)
    return schemas.Msg(code=200, msg='ok', data=data)


# 待入职阶段查询
@router.post("/interview_waite_in_find")
async def interview_find(
        request: Request,
        interview: InterviewDo = Depends(InterviewDo),
        db: CKDrive = Depends(get_ck_db),
) -> schemas.Msg:
    """ interview面试数据待入职阶段查询 """
    await interview.init()
    res = interview.find_interview_waite_in_sql()
    sql = res['sql']
    data = await db.execute(sql)
    if not data:
        return schemas.Msg(code=-9, msg='无数据', data=None)
    return schemas.Msg(code=200, msg='ok', data=data)


# 面试修改
@router.post("/interview_update")
async def interview_update(
        request: Request,
        interview: InterviewDo = Depends(InterviewDo),
        db: CKDrive = Depends(get_ck_db),
) -> schemas.Msg:
    """ interview面试数据更新 """
    await interview.init()
    res = interview.update_interview_sql()
    sql = res['sql']
    try:
        data = await db.execute(sql)
    except:
        return schemas.Msg(code=-9, msg='数据有误', data=None)
    return schemas.Msg(code=200, msg='ok', data=data)


# 写入面试数据
@router.post("/interview_insert")
async def interview_insert(
        request: Request,
        interview: InterviewDo = Depends(InterviewDo),
        db: CKDrive = Depends(get_ck_db),
) -> schemas.Msg:
    """ interview面试数据写入 """
    await interview.init()
    res = interview.insert_interview_sql()
    sql = res['sql']
    insert_data = res['insert_data']
    data = await db.execute_dict(sql, insert_data)
    return schemas.Msg(code=200, msg='ok', data=data)


# 导入面试数据
@router.post("/interview_file_insert")
async def interview_insert(
        request: Request,
        file: UploadFile = File(...),
) -> schemas.Msg:
    """ interview面试数据导入 """
    path_data = os.getcwd() + '/jianli/'  # 当前文件所在的目录
    contents = await file.read()
    filename = file.filename
    try:
        with open(path_data + filename, "wb") as f:
            #  将获取的file文件内容，写入到新文件中
            f.write(contents)
            f.close()
    except:
        return schemas.Msg(code=400, msg='上传文件有误', data=None)
    data = get_resume(filename, path_data)
    education = data['education']
    # 学历int转化
    education_int = {
        '大专': 1,
        '本科': 2,
        '研究生': 3,
        '博士': 4,
        '硕士': 5,
    }
    if education and isinstance(education, str):
        data['education'] = education_int.get(education, 1)
    age = data['age']
    if not age:
        data['age'] = 20
    # 年龄int转化
    if age and isinstance(age, str):
        true_age = re.search(r"\d+\.?\d*", age)
        if len(true_age.group()) > 2:
            data['age'] = 20
        else:
            data['age'] = int(true_age.group())
    work_exp = data['work_exp']
    if not work_exp:
        data['work_exp'] = 0
    # 工作经验float转化
    if work_exp and isinstance(work_exp, str):
        true_work_exp = re.search(r"\d+\.?\d*", work_exp)
        if len(true_work_exp.group()) > 3:
            data['work_exp'] = 0
        else:
            data['work_exp'] = float(true_work_exp.group())
    print(data)
    return schemas.Msg(code=200, msg='ok', data=data)


@router.post("/add_job")
async def event_edit(
        request: Request,
        data_in: schemas.Ins_Job,
        db: AsyncIOMotorDatabase = Depends(get_database),
) -> schemas.Msg:
    """新增职位"""
    await crud.jobs.insert_job(db, data_in)
    return schemas.Msg(code=200, msg='ok', data='')


@router.post("/condition")
async def interview_insert(
        request: Request,
        data_in: schemas.Interview,
        ckdb: CKDrive = Depends(get_ck_db)
) -> schemas.Msg:
    """ 面试情况 """
    res = data_in.date
    strs = []
    for k, v in res.items():
        if v != '':
            if 'int' in str(type(v)):
                str_s = f"{k} = {v}"
                strs.append(str_s)
            else:
                str_s = f"{k} = '{v}'"
                strs.append(str_s)
    where = ' and '.join(strs)
    # 当前日期
    times = get_time()
    # 今天的面试
    if data_in.time_type == 'now':
        #  查询返回的数据一共多少条
        len_sql = f"""select uid from HR.resumes where {where} and toDate(star_time) == '{times}' ORDER BY event_time"""
        sql = f"""select interview_round,interview_type,star_time,end_time,name,phone,job_name,hr_name,
                 feedback,interview_name from HR.resumes where {where} and toDate(star_time) == '{times}' ORDER BY event_time 
                 LIMIT 10 OFFSET {(data_in.pages - 1) * 10}"""
    # 明天及之后的面试
    elif data_in.time_type == 'tomorrow':
        len_sql = f"""select uid from HR.resumes where {where} and toDate(star_time) > '{times}' ORDER BY event_time"""
        sql = f"""select interview_round,interview_type,star_time,end_time,name,phone,job_name,hr_name,
                 feedback,interview_name from HR.resumes where {where} and toDate(star_time) > '{times}' ORDER BY event_time 
                 LIMIT 10 OFFSET {(data_in.pages - 1) * 10}"""
    # 昨天及以前的面试
    else:
        len_sql = f"""select uid from HR.resumes where {where} and toDate(star_time) < '{times}' ORDER BY event_time"""
        sql = f"""select interview_round,interview_type,star_time,end_time,name,phone,job_name,hr_name,
                 feedback,interview_name from HR.resumes where {where} and toDate(star_time) < '{times}' ORDER BY event_time 
                 LIMIT 10 OFFSET {(data_in.pages - 1) * 10}"""
    if where == '':
        len_sql = len_sql.replace('where  and', 'where', 1)
        sql = sql.replace('where  and', 'where', 1)
    # 返回数据条数
    df_len = await ckdb.query_dataframe(len_sql)
    len_date = len(df_len)
    df = await ckdb.query_dataframe(sql)
    if df.empty:
        return schemas.Msg(code=-9, msg='无数据', data='')
    data = {'lens': len_date,
            'columns': df.columns.tolist(),
            'values': df.values.tolist()
            }
    return schemas.Msg(code=200, msg='ok', data=data)


@router.post("/get_job")
async def event_edit(
        request: Request,
        data_in: schemas.Jobs = None,
        db: AsyncIOMotorDatabase = Depends(get_database)
) -> schemas.Msg:
    """获取职位名称"""
    # 获取对应条件的职位
    res = await crud.jobs.all_fields(db, data_in)
    # 获取职位数量
    num = len(res)
    job_list = []
    job_id = []
    for i in res:
        # 获取职位名称
        job_list.append(i['job_name'])
        job_id.append(i['job_id'])
    data = {
        'num': num,
        'job_list': job_list,
        'job_id': job_id
    }
    return schemas.Msg(code=200, msg='ok', data=data)


@router.post("/download_interview")
async def download_inter(
        request: Request,
        data_in: schemas.Timesinter,
        ckdb: CKDrive = Depends(get_ck_db)):
    """导出所有面试安排"""
    sql = f"""SELECT interview_type,interview_stage,star_time,end_time,name,phone,job_name,hr_name,interview_name,
    interview_sign FROM HR.resumes WHERE toDate(star_time) >= '{data_in.start_time}' and toDate(star_time) <= '{data_in.end_time}'"""
    df = await ckdb.query_dataframe(sql)
    # xlsx表名
    xlsx_name = data_in.start_time + '~' + data_in.end_time + '(包含起止日)'
    datas = []
    for i in range(len(df)):
        one_data = []
        one_data.append(interview_type_dict[df['interview_type'][i]])
        one_data.append(interview_stage_dict[df['interview_stage'][i]])
        df_time = qujian_time(df['star_time'][i], df['end_time'][i])
        one_data.append(df_time)
        one_data.append(df['name'][i])
        one_data.append(df['phone'][i])
        one_data.append(df['job_name'][i])
        one_data.append(df['hr_name'][i])
        one_data.append(df['interview_name'][i])
        one_data.append(interview_sign_dict[df['interview_sign'][i]])
        datas.append(one_data)
    columns = ['面试类型', '面试阶段', '面试时间', '候选人', '联系方式', '应聘职位', '面试负责人', '面试官', '面试签到']
    dfmi = pd.DataFrame(data=datas, columns=columns)
    Download = Download_xlsx(dfmi, xlsx_name)
    return Download


@router.post("/add_remark")
async def event_edit(
        request: Request,
        data_in: schemas.BaseRemark,
        db: AsyncIOMotorDatabase = Depends(get_database),
) -> schemas.Msg:
    """添加备注"""
    await crud.api_interview_remark.insert_remark(db, data_in)
    return schemas.Msg(code=200, msg='ok', data='')


@router.post("/find_remark")
async def event_edit(
        request: Request,
        data_in: schemas.FindRemark,
        db: AsyncIOMotorDatabase = Depends(get_database),
) -> schemas.Msg:
    """查找备注"""
    data = await crud.api_interview_remark.get_interview_remarks(db, data_in)
    return schemas.Msg(code=200, msg='ok', data=data)


@router.post("/find_criterion")
async def event_edit(
        request: Request,
        data_in: schemas.get_uid,
        ckdb: CKDrive = Depends(get_ck_db)
) -> schemas.Msg:
    """获取标准版简历"""
    sql = f"""
    select name,phone,job_name,work_exp,owner_name,education,work_undergo,school,specialty,
    graduate_time,mail,account,id_card,gender,nation,age,at_school,specialty_do,hope_money,resume_affix_id,
    review,work_list,project_undergo,upgrade,come_time,now_money,work_in_time from HR.resumes WHERE uid = '{data_in.uid}'
    """
    df = await ckdb.query_dataframe(sql)
    data = {}
    column = df.columns
    for i in column:
        data[i] = df[i][0]
    return schemas.Msg(code=200, msg='ok', data=data)


@router.post("/resume_affix")
async def event_edit(
        request: Request,
        data_in: schemas.Post_uid,
        ckdb: CKDrive = Depends(get_ck_db)
) -> schemas.Msg:
    """保存附件id"""
    sql = f"""
    ALTER table HR.resumes update resume_affix_id = {data_in.resume_affix_id} WHERE uid = '{data_in.uid}'
    """
    await ckdb.execute(sql)
    return schemas.Msg(code=200, msg='ok', data='')


@router.post("/updata_entry")
async def event_edit(
        request: Request,
        data_in: schemas.Entry,
        ckdb: CKDrive = Depends(get_ck_db)
) -> schemas.Msg:
    """修改入职状态"""
    sql = f"""
    ALTER table HR.resumes update interview_stage = {data_in.interview_stage} WHERE uid = '{data_in.uid}'
    """
    await ckdb.execute(sql)
    return schemas.Msg(code=200, msg='ok', data='')


@router.post("/get_str_mail")
async def event_edit(
        request: Request,
        data_in: schemas.Email_str,
        ckdb: CKDrive = Depends(get_ck_db)
) -> schemas.Msg:
    """获取邮件文本"""
    data = f"""
        {data_in.name},您好\n\n感谢关注乐谷在线科技有限公司！很高兴的通知您通过了我们的面试，真诚的邀请您加入我们的团队\n职位：{data_in.job}\n入职时间：{data_in.times}
        \n薪酬：{data_in.money}\n联系人：{data_in.hr_name}\n联系电话：{data_in.phone}\n联系邮箱：{data_in.email}\n\n如有问题请用以上联系方式及时与我们沟通，谢谢！\n（系统邮件，请勿回复）
    """
    return schemas.Msg(code=200, msg='ok', data=data)


@router.post("/send_str_mail")
async def event_edit(
        request: Request,
        data_in: schemas.send_str_mail,
        db: AsyncIOMotorDatabase = Depends(get_database)
) -> schemas.Msg:
    """发送邮件"""
    try:
        # 发送邮件
        send_str_mail(data_in.email_str, data_in.email)
        # 保存发送邮件的记录
        now_time = str(datetime.now()).split('.')[0]
        await crud.email_record.create(db, schemas.email_record(user_id=data_in.user_id, text=data_in.email_str,
                                                                times=now_time))
        return schemas.Msg(code=200, msg='邮件发送成功', data='')
    except Exception:
        return schemas.Msg(code=200, msg='邮件发送失败', data='')


@router.post("/email_record")
async def event_edit(
        request: Request,
        data_in: schemas.get_email_record,
        db: AsyncIOMotorDatabase = Depends(get_database)
) -> schemas.Msg:
    """获取发送邮件的记录"""
    data = await crud.email_record.all_record(db, data_in)
    return schemas.Msg(code=200, msg='ok', data=data)


@router.post("/operate_log")
async def event_edit(
        request: Request,
        data_in: schemas.operate_log,
        db: AsyncIOMotorDatabase = Depends(get_database)
) -> schemas.Msg:
    """同步插入操作记录"""
    await crud.operate_log.create(db, data_in)
    return schemas.Msg(code=200, msg='ok', data='')


@router.post("/get_operate_log")
async def event_edit(
        request: Request,
        data_in: schemas.get_operate_log,
        db: AsyncIOMotorDatabase = Depends(get_database)
) -> schemas.Msg:
    """获取操作记录"""
    data = await crud.operate_log.all_log(db, data_in)
    # 对时间进行排序
    data = sorted(data, key=operator.itemgetter('times'))
    return schemas.Msg(code=200, msg='ok', data=data)


@router.get("/get_dding_user")
async def event_edit(
        request: Request,
) -> schemas.Msg:
    """获取钉钉的用户id"""
    data = get_redis_alluid()
    return schemas.Msg(code=200, msg='ok', data=data)


@router.post("/teacher_state")
async def event_edit(
        request: Request,
        data_in: schemas.user_id,
        db: AsyncIOMotorDatabase = Depends(get_database)
) -> schemas.Msg:
    """催促面试官反馈功能"""
    # 同步钉钉发消息给面试官
    try:
        now_time = str(datetime.now()).split('.')[0]
        content=f"【催促反馈】\n请面试官尽快给{data_in.name}做面试反馈\n提醒时间：{now_time}"
        send_dates(content,data_in.user_id)
        return schemas.Msg(code=200, msg='发送成功', data='')
    except Exception:
        return schemas.Msg(code=-9, msg='发送失败', data='')


@router.post("/add_mode")
async def event_edit(
        request: Request,
        data_in: schemas.InsertModes,
        db: AsyncIOMotorDatabase = Depends(get_database),
) -> schemas.Msg:
    """添加hr分组"""
    await crud.api_interview_modes.insert_modes(db, data_in)
    return schemas.Msg(code=200, msg='ok', data='')


@router.post("/find_mode")
async def event_edit(
        request: Request,
        data_in: schemas.FindModes,
        db: AsyncIOMotorDatabase = Depends(get_database),
) -> schemas.Msg:
    """查找hr所有分组"""
    data = await crud.api_interview_modes.get_interview_modes(db, data_in)
    return schemas.Msg(code=200, msg='ok', data=data)


@router.post("/update_mode")
async def event_edit(
        request: Request,
        data_in: schemas.UpdateModes,
        db: AsyncIOMotorDatabase = Depends(get_database),
) -> schemas.Msg:
    """更新一条hr分组数据"""
    await crud.api_interview_modes.update_modes(db, data_in)
    return schemas.Msg(code=200, msg='ok', data='')


@router.get("/name")
async def event_edit(
        request: Request,
        db: AsyncIOMotorDatabase = Depends(get_database),
) -> schemas.Msg:
    """获取所有用户角色"""
    res = await crud.user.get_all_users(db,{})
    data=[]
    for i in res:
        data_dict={}
        data_dict['name']=i.get('name')
        data_dict['email']=i.get('email')
        data.append(data_dict)
    return schemas.Msg(code=200, msg='ok', data=data)


@router.post("/amend_job")
async def event_edit(
        request: Request,
        data_in: schemas.Jobs,
        db: AsyncIOMotorDatabase = Depends(get_database),
) -> schemas.Msg:
    """修改职位信息，修改职位招聘状态"""
    await crud.jobs.update_job(db, data_in)
    return schemas.Msg(code=200, msg='ok', data='')