import uuid
import datetime
from typing import List, Optional
from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from pydantic import BaseModel
from sqlalchemy import create_engine, Column, String, Float, ForeignKey, DateTime, Text
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, Session, relationship
from jose import JWTError, jwt
from passlib.context import CryptContext

# --- STEP 1: DATABASE SETUP (SQLAlchemy) ---
# We use SQLite in-memory for the demo (in production, this is PostgreSQL).
SQLALCHEMY_DATABASE_URL = "sqlite:///./baas_bank.db"
engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

# Define the Database Models
class UserModel(Base):
    __tablename__ = "users"
    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    email = Column(String, unique=True, index=True)
    hashed_password = Column(String)
    kyc_status = Column(String, default="PENDING")
    accounts = relationship("AccountModel", back_populates="user")

class AccountModel(Base):
    __tablename__ = "accounts"
    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    user_id = Column(String, ForeignKey("users.id"))
    currency = Column(String, default="USD")
    user = relationship("UserModel", back_populates="accounts")
    ledger_entries = relationship("LedgerEntryModel", back_populates="account")

class LedgerEntryModel(Base):
    __tablename__ = "ledger_entries"
    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    account_id = Column(String, ForeignKey("accounts.id"))
    amount = Column(Float) # Negative = Debit, Positive = Credit
    transaction_id = Column(String, ForeignKey("transactions.id"))
    created_at = Column(DateTime, default=datetime.datetime.now)
    account = relationship("AccountModel", back_populates="ledger_entries")

class TransactionModel(Base):
    __tablename__ = "transactions"
    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
    from_account_id = Column(String, ForeignKey("accounts.id"))
    to_account_id = Column(String, ForeignKey("accounts.id"))
    amount = Column(Float)
    status = Column(String, default="PENDING")
    idempotency_key = Column(String, unique=True, index=True) # THE KEY!
    created_at = Column(DateTime, default=datetime.datetime.now)

Base.metadata.create_all(bind=engine)

# --- STEP 2: AUTHENTICATION SETUP ---
SECRET_KEY = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

def verify_password(plain_password, hashed_password):
    return pwd_context.verify(plain_password, hashed_password)

def get_password_hash(password):
    return pwd_context.hash(password)

def create_access_token(data: dict):
    to_encode = data.copy()
    expire = datetime.datetime.utcnow() + datetime.timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(lambda: SessionLocal())):
    credentials_exception = HTTPException(status_code=401, detail="Could not validate credentials")
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        user_id: str = payload.get("sub")
        if user_id is None:
            raise credentials_exception
    except JWTError:
        raise credentials_exception
    user = db.query(UserModel).filter(UserModel.id == user_id).first()
    if user is None:
        raise credentials_exception
    return user

# --- STEP 3: PYDANTIC SCHEMAS (Data Validation) ---
class UserCreate(BaseModel):
    email: str
    password: str

class AccountResponse(BaseModel):
    id: str
    currency: str

class TransferRequest(BaseModel):
    from_account_id: str
    to_account_id: str
    amount: float
    idempotency_key: str # Client must provide this!

class TransferResponse(BaseModel):
    transaction_id: str
    status: str
    from_balance: float
    to_balance: float

# --- STEP 4: FASTAPI APP INITIALIZATION ---
app = FastAPI(title="BaaS Core Banking Capstone API")

# Dependency to get DB session
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

# --- STEP 5: AUTH ENDPOINTS ---
@app.post("/register")
async def register_user(user: UserCreate, db: Session = Depends(get_db)):
    # Check if email exists
    existing_user = db.query(UserModel).filter(UserModel.email == user.email).first()
    if existing_user:
        raise HTTPException(status_code=400, detail="Email already registered")
    
    # Create User
    hashed_pw = get_password_hash(user.password)
    new_user = UserModel(email=user.email, hashed_password=hashed_pw)
    db.add(new_user)
    db.flush() # Flush to get the new ID before creating account
    
    # Create a default USD account for them
    new_account = AccountModel(user_id=new_user.id)
    db.add(new_account)
    db.commit()
    
    return {"user_id": new_user.id, "account_id": new_account.id, "status": "created"}

@app.post("/token")
async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)):
    user = db.query(UserModel).filter(UserModel.email == form_data.username).first()
    if not user or not verify_password(form_data.password, user.hashed_password):
        raise HTTPException(status_code=401, detail="Incorrect email or password")
    access_token = create_access_token(data={"sub": user.id})
    return {"access_token": access_token, "token_type": "bearer"}

# --- STEP 6: LEDGER API ENDPOINTS ---
@app.get("/accounts", response_model=List[AccountResponse])
async def list_accounts(current_user: UserModel = Depends(get_current_user), db: Session = Depends(get_db)):
    # Only return the accounts belonging to the authenticated user
    accounts = db.query(AccountModel).filter(AccountModel.user_id == current_user.id).all()
    return [{"id": acc.id, "currency": acc.currency} for acc in accounts]

@app.post("/transfer", response_model=TransferResponse)
async def create_transfer(request: TransferRequest, current_user: UserModel = Depends(get_current_user), db: Session = Depends(get_db)):
    """
    The Crown Jewel of the Capstone.
    Handles the money transfer with strict Double-Entry and Idempotency Enforcement.
    """
    # 1. IDEMPOTENCY CHECK
    existing_txn = db.query(TransactionModel).filter(TransactionModel.idempotency_key == request.idempotency_key).first()
    if existing_txn:
        # If we find a previous transaction with this key, return the previous result immediately!
        return {
            "transaction_id": existing_txn.id,
            "status": existing_txn.status,
            "from_balance": 0.0, # In production, we would query and return real balances here.
            "to_balance": 0.0
        }

    # 2. ATOMIC VALIDATION
    from_acc = db.query(AccountModel).filter(AccountModel.id == request.from_account_id).first()
    to_acc = db.query(AccountModel).filter(AccountModel.id == request.to_account_id).first()
    
    if not from_acc or not to_acc:
        raise HTTPException(status_code=404, detail="One or both accounts not found")
    
    # Verify the sender owns the 'from' account
    if from_acc.user_id != current_user.id:
        raise HTTPException(status_code=403, detail="Sender does not own the source account")

    # Verify balance (Sum of ledger entries is the balance)
    from_balance = db.query(LedgerEntryModel).filter(LedgerEntryModel.account_id == from_acc.id).with_entities(LedgerEntryModel.amount).all()
    current_balance = sum([entry[0] for entry in from_balance])
    if current_balance < request.amount:
        raise HTTPException(status_code=400, detail="Insufficient funds")

    # 3. THE DATABASE TRANSACTION
    # (In SQLAlchemy, we wrap the operations in a session context)
    try:
        # Create the Transaction Record (to store the idempotency key)
        new_txn = TransactionModel(
            from_account_id=request.from_account_id,
            to_account_id=request.to_account_id,
            amount=request.amount,
            idempotency_key=request.idempotency_key,
            status="SETTLED"
        )
        db.add(new_txn)
        db.flush() # Flush to get the ID

        # Create Ledger Entry 1: Debit (Negative)
        debit = LedgerEntryModel(
            account_id=request.from_account_id,
            amount=-request.amount,
            transaction_id=new_txn.id
        )
        db.add(debit)

        # Create Ledger Entry 2: Credit (Positive)
        credit = LedgerEntryModel(
            account_id=request.to_account_id,
            amount=request.amount,
            transaction_id=new_txn.id
        )
        db.add(credit)

        db.commit() # Commit ALL changes. If anything fails, the whole thing rolls back.

        # Recalculate final balances for the response
        final_from_balance = sum([entry[0] for entry in db.query(LedgerEntryModel).filter(LedgerEntryModel.account_id == from_acc.id).with_entities(LedgerEntryModel.amount).all()])
        final_to_balance = sum([entry[0] for entry in db.query(LedgerEntryModel).filter(LedgerEntryModel.account_id == to_acc.id).with_entities(LedgerEntryModel.amount).all()])

        return {
            "transaction_id": new_txn.id,
            "status": "SETTLED",
            "from_balance": round(final_from_balance, 2),
            "to_balance": round(final_to_balance, 2)
        }
        
    except Exception as e:
        db.rollback()
        raise HTTPException(status_code=500, detail=f"Transaction failed: {str(e)}")

# --- STEP 7: RUNNING THE APP ---
# To run: uvicorn main:app --reload
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)