from fastapi import HTTPException
from sqlalchemy.orm import Session
from sqlalchemy import and_, Date
from model.employment import EmploymentBase,EmploymentOffer
from model.students import Student
# ========== 就业基础信息 DAO ==========
class EmploymentBaseDAO:
    @staticmethod
    #根据学生编号查询
    def get_by_stu_id(db: Session, stu_id: int):
        record = db.query(EmploymentBase).filter(and_(
            EmploymentBase.stu_id == stu_id,
            EmploymentBase.is_deleted == 0
        )).first()
        return record
    @staticmethod
    #多条件查询
    def different_choice_query(
            db: Session,
            stu_id: int = None,
            company_name: str = None,
            min_salary: float = None,
            max_salary: float = None,
            skip: int = 0,
            limit: int = 10
    ):
        # 基础查询 + 过滤未删除
        query = db.query(EmploymentBase).filter(EmploymentBase.is_deleted == 0)

        # 动态拼接条件
        #学生id查询
        if stu_id is not None:
            query = query.filter(EmploymentBase.stu_id == stu_id)
        #公司名称查询
        if company_name is not None and company_name.strip() != "":
            # 模糊匹配，%代表通配符
            query = query.filter(EmploymentBase.company_name.like(f"%{company_name}%"))
        #工资范围查询
        if min_salary is not None:
            query = query.filter(EmploymentBase.salary >= min_salary)
        if max_salary is not None:
            query = query.filter(EmploymentBase.salary <= max_salary)

        # 分页
        result = query.offset(skip).limit(limit).all()
        return result

    @staticmethod
    #新增学生就业基础信息
    def create(db: Session, obj: EmploymentBase):

        student = db.query(Student).filter(
            Student.stu_id == obj.stu_id,
            Student.is_deleted == 0
        ).first()
        if not student:
            raise HTTPException(status_code=400, detail="学生不存在或已逻辑删除，不能添加就业信息")
        db.add(obj)
        db.commit()
        db.refresh(obj)
        return obj

    @staticmethod
    #更新就业基础信息
    def update(db: Session, stu_id: int, update_data: dict):
        record = EmploymentBaseDAO.get_by_stu_id(db, stu_id)
        if not record:
            return None

        if "company_name" in update_data:
            record.company_name = update_data["company_name"]
        if "salary" in update_data:
            record.salary = update_data["salary"]
        if "employment_open_time" in update_data:
            record.employment_open_time = update_data["employment_open_time"]
        if "job_time" in update_data:
            record.job_time = update_data["job_time"]
        # =========== 统一时间校验 ===========
        final_emp_open = record.employment_open_time
        final_job = record.job_time
        # 两个时间都不为空才校验
        if final_emp_open and final_job:
            if final_job < final_emp_open:
                raise ValueError("job时间不能早于就业开放时间")

        db.commit()
        db.refresh(record)
        return record

    @staticmethod
    #根据学生编号对就业基础表进行逻辑删除
    def delete(db: Session, stu_id: int):
        record = EmploymentBaseDAO.get_by_stu_id(db, stu_id)
        if not record:
            return False
        record.is_deleted = 1
        db.commit()
        return True

# ========== 就业Offer协议 DAO ==========
class EmploymentOfferDAO:

    @staticmethod
    #添加就业协议记录
    def create(db: Session, obj_1: EmploymentOffer,obj_2:EmploymentBase):
        # 时间校验
        if obj_1.offer_time < obj_2.employment_open_time:
            raise ValueError("offer时间不能早于就业开放时间")
        db.add(obj_1)
        db.commit()
        db.refresh(obj_1)
        return obj_1

    @staticmethod
    #修改就业协议表
    def update(db: Session, stu_id: int, offer_id: int, offer_time:Date):
        """修改offer"""
        record_list = EmploymentOfferDAO.different_choice_query(db, stu_id, offer_id)
        if not record_list:
            return None
        record = record_list[0]
        #查询就业基础信息，拿到就业开放时间准备做时间校验
        base_record = db.query(EmploymentBase).filter(
            EmploymentBase.stu_id == stu_id,
            EmploymentBase.is_deleted == 0
        ).first()
        #避免就业基础信息被逻辑删除了而就业基础协议记录还存在
        if not base_record:
            raise ValueError("未找到该学生就业基础信息")
        #时间校验
        if offer_time is not None:
            if offer_time < base_record.employment_open_time:
                raise ValueError("offer时间不能早于就业开放时间")
            record.offer_time = offer_time

        db.commit()
        db.refresh(record)
        return record

    @staticmethod
    #根据协议编号对就业协议表进行逻辑删除
    def delete(db: Session, stu_id: int,offer_id: int):
        """offer逻辑删除"""
        record_list = EmploymentOfferDAO.different_choice_query(db, stu_id,offer_id)
        if not record_list:
            return False
        record = record_list[0]
        record.is_deleted = 1
        db.commit()
        return True

    @staticmethod
    #多条件查询就业协议表
    def different_choice_query(
            db: Session,
            stu_id: int =None ,
            offer_id: int = None,
            skip: int = 0,
            limit: int = 10
    ):
        #基础查询+过滤未删除
        query = db.query(EmploymentOffer).filter(EmploymentOffer.is_deleted == 0)

        #动态拼接条件
        #学生id查询(选填)
        if stu_id is not None:
            query = query.filter(EmploymentOffer.stu_id == stu_id)
            # 同时传了offer编号 → 查单个（联合主键两个都查）
            if offer_id is not None:
                query = query.filter(EmploymentOffer.offer_id == offer_id)
        elif stu_id is None and offer_id is not None:
            raise ValueError("不能单独查询offer编号，必须同时提供学生编号")
                # 分页
        result = query.offset(skip).limit(limit).all()
        return result