# backend/main.py
import bcrypt
import api.models.models as models

from fastapi import FastAPI, HTTPException, Depends, Response

from starlette.middleware import Middleware
from starlette.middleware.cors import CORSMiddleware

from typing import Annotated
from sqlalchemy.orm import Session
from pydantic import BaseModel, Field

from api.database.database import SessionLocal, engine
from api.routers.routes import router

from api.validation.account_validation import (
    validate_email,
    validate_password,
    is_name_not_in_password,
    validate_universal_phone_number,
    hash_password
)

cors_middleware = [
    Middleware(
        CORSMiddleware,
        allow_origins=[
            "http://localhost:3000",
            "http://localhost:3001",
            "http://127.0.0.1:3000",
            "http://127.0.0.1:3001"
        ],
        allow_credentials=True,
        allow_headers=["*"],
        allow_methods=["*"]
    )
]

app = FastAPI(middleware=cors_middleware)
app.include_router(router)

class UserBase(BaseModel):
    first_name: str = Field(alias="firstName")
    last_name: str = Field(alias="lastName")
    email_address: str = Field(alias="emailAddress")
    phone_number: str = Field(alias="phoneNumber")
    password: str = Field(alias="password")
    dob: str = Field(alias="dateOfBirth")

class UserModel(UserBase):
    id: int

    class Config:
        from_attributes = True

class LoginModel(BaseModel):
    email_address: str = Field(alias="emailAddress")
    password: str = Field(alias="password")

class LoginResponseModel(BaseModel):
    user_name: str = Field(alias="userName")
    logged_in: bool = Field(alias="loggedIn")

def map_user_to_login_response(user: models.User):
    user_name = user.first_name[0] + user.last_name[0]
    return LoginResponseModel(user_name = user_name, logged_in = True)

def get_db():
    db = SessionLocal()

    try:
        yield db
    finally:
        db.close()

db_dependency = Annotated[Session, Depends(get_db)]
models.Base.metadata.create_all(bind=engine)

@app.post("/create_account/")
async def create_new_user(user: UserBase, db: db_dependency):
    if not validate_email(user.email_address):
        raise HTTPException(status_code=400, detail="Not A Valid Email")

    if not validate_password(user.password):
        raise HTTPException(status_code=400, detail="Not A Valid Password")

    if not is_name_not_in_password(user.first_name, user.last_name, user.password):
        raise HTTPException(status_code=400, detail="Name Cannot Be In Password")

    if not validate_universal_phone_number(user.phone_number):
        raise HTTPException(status_code=400, detail="Invalid Phone Number")

    query = db.query(models.User.id).filter(models.User.email_address == user.email_address)
    user_exists = db.query(query.exists()).scalar()

    if user_exists:
        raise HTTPException(status_code=409, detail="User Already Exists")

    user.password = hash_password(user.password)

    user = models.User(**user.model_dump())

    db.add(user)
    db.commit()
    db.refresh(user)
    return user

@app.get("/")
async def root():
    return { "message": "Welcome To Mek's Hub!" }

@app.post("/login/")
async def check_user_login(user: LoginModel, db: db_dependency):
    db_user = db.query(models.User).filter(models.User.email_address == user.email_addres).first()

    if db_user is None:
        raise HTTPException(status_code=400, detail="Email Address/Password Invalid")

    enc_pw = db.user.password
    inc_pw = user.password.encode("utf-8")

    if bcrypt.checkpw(inc_pw, enc_pw) == False:
        raise HTTPException(status_code=409, detail="Email Address/Password Does Not Match")

    return map_user_to_login_response(db_user)