from fastapi.security import OAuth2PasswordRequestForm
import app.api.auth.schemas as schemas
from sqlalchemy.orm import Session
from app.dependency.authantication import JWTManager
from app.models.main.admin import TblAdmin
from app.models.main.company_list import TblCompanyList
from app.models.main.seafarer_role import SeafarererRoleBase, TblSeafarerRole
from app.models.main.users import TblUsers, UsersBase
from app.utils.schemas_utils import CustomResponse
class AuthService:
    def __init__(self, db: Session,token: dict):
        self.db = db
        self.token = token

    async def create_user(self, request: schemas.UserCreate):
        created_user = UsersBase.model_validate(request)
        TblUsers.create(created_user, self.db)
        self.db.commit()
        return CustomResponse(status="1", message="User created successfully")

    async def user_login(self, credentials: OAuth2PasswordRequestForm):
        user_log = TblUsers.get_by_user_filter(credentials, self.db)
        if not user_log:
            return CustomResponse(status="-1", message="Please enter a valid user name")
        if credentials.password != user_log.password:
            return CustomResponse(status="-2", message="Incorrect password")
        token_payload = {
            "sub": user_log.user_name,
            "user_id": user_log.usr_id,
            "role_id": user_log.role_id,
            "admin_id": None,
            "seafarer_id": None,
            "company_id": None
        }
        if user_log.role_id in {1, 2, 3}:
            token_payload["admin_id"] = user_log.entity_id
            company = self.db.query(TblCompanyList).join(TblAdmin).filter(
                TblAdmin.admin_id == user_log.entity_id
            ).first()
            if company:
                token_payload["company_id"] = company.company_id
        elif user_log.role_id == 4:
            token_payload["seafarer_id"] = user_log.entity_id
        else:
            return CustomResponse(status="-3", message="User role not supported")
        access_token = JWTManager.create_access_token(token_payload)
        refresh_token = JWTManager.create_refresh_token(token_payload)
        return {
            "access_token": access_token,
            "refresh_token": refresh_token,
            "token_payload": token_payload
        }

    async def update_user(self, request: schemas.UserUpdate):
        updated_user = UsersBase.model_validate(request)
        if updated_user.usr_id is None:
            return CustomResponse(status="-1", message="User id not found")
        TblUsers.update(updated_user.usr_id, updated_user, self.db)
        self.db.commit()
        return CustomResponse(status="1", message="User updated successfully")

    async def create_role(self, request: schemas.SeafarerRoleCreate):
        created_user = SeafarererRoleBase.model_validate(request) 
        TblSeafarerRole.create(created_user, self.db)
        self.db.commit()
        return CustomResponse(status="1", message="Role created successfully")
    
    async def get_all_roles(self):
        roles = self.db.query(TblSeafarerRole).all()
        roles_data = [schemas.SeafarerRole.model_validate(role).model_dump() for role in roles]
        return CustomResponse(status="1", message="Roles fetched successfully", data=roles_data)
    
    async def update_role(self,request: schemas.SeafarererRoleUpdate):
        updated_user_role = SeafarererRoleBase.model_validate(request)
        if updated_user_role.sf_role_id is None:
            return CustomResponse(status="-1", message="User id not found")
        TblSeafarerRole.update(updated_user_role.sf_role_id, updated_user_role, self.db)
        self.db.commit()
        return CustomResponse(status="1", message="User Role updated successfully")