from flask import request, jsonify, make_response, g, send_file
from src.utils.response import error_response
from src.models import SchoolTable
from sqlalchemy import Select, func
from src import db
from src.lib.bcrypt import encrypt_password, check_password
from src.lib.jwt import generate_token
from src.models import PrincipalTable
from env import UPLOAD_FOLDER
from werkzeug.utils import secure_filename
import os
from datetime import datetime
from src.utils.upload_file import (
    allowed_file,
    generate_excel_report,
    process_student_file,
    process_teacher_file,
    validate_headers
)

def login_func():
    body = request.get_json() or {}
    school_name = body.get("school_name", "").strip().lower()
    school_id = body.get("school_id")
    password = body.get("password")

    if not school_name or not school_id or not password:
        return error_response("All fields are required!", 400)

    stmt = Select(SchoolTable).where(
        func.lower(func.trim(SchoolTable.school_name)) == school_name,
        SchoolTable.school_id == school_id
    )
    school = db.session.execute(stmt).scalar_one_or_none()

    if not school:
        return error_response("Invalid Credential", 400)

    if not school.isLoggedIn:
        school.password = encrypt_password(password)
        school.isLoggedIn = True
        db.session.commit()
        message = "Welcome! Your account has been successfully activated and your password has been set."
    else:
        stored_password = school.password
        if isinstance(stored_password, bytes):
            stored_password = stored_password.decode('utf-8')
        
        if not check_password(stored_password, password):
            return error_response("Invalid Credential", 409)
        message = "Login successful. Welcome back!"

    token = generate_token(school.id, "school")

    response = make_response(jsonify({
        "success": True,
        "message": message,
        "school": {
            "id": school.id,
            "school_name": school.school_name,
            "school_id": school.school_id
        }
    }), 200)

    # response.set_cookie(
    #     "auth_token",
    #     token,
    #     httponly=True,
    #     samesite="lax",
    #     path="/",
    #     max_age=7 * 24 * 60 * 60  
    # )
    
    response.set_cookie(
        "auth_token",
        token,
        httponly=True,
        secure=True,             
        samesite="None",         
        path="/",
        domain=".beyondskool.ai", 
        max_age=7 * 24 * 60 * 60
    )   

    return response


def principal_func():
    school = g.current_user
    school_id = school.id
    if not school:
        return error_response("School not found", 404)
        
    body = request.get_json()
    firstname = body.get("firstname")
    lastname = body.get("lastname")
    username = body.get("username")
    password = body.get("password")

    if not firstname or not username or not password:
        return error_response("All fields are required", 404)
        
    stmt1 = Select(PrincipalTable).where(PrincipalTable.username == username)
    is_exist = db.session.execute(stmt1).scalar_one_or_none()

    if is_exist:
        return error_response("Username is already exist! Please try with diffrent username", 409)
        
    principal = PrincipalTable(
            firstname=firstname,
            lastname=lastname,
            username=username,
            password=password,
            school_id=school_id
        )

    db.session.add(principal)
    db.session.commit()

    return jsonify({
        "success": True,
        "message": "Principal Added successfully with default password"
    }), 201


def upload_func():
    school = g.current_user
        
    if not school:
        return error_response("No active school found", 404)
        
    if 'file' not in request.files:
        return error_response("No file provided", 404)
        
    file = request.files['file']
    if file.filename == '':
        return error_response("No file selected", 400)
        
    if not allowed_file(file.filename):
        return error_response("Invalid file type. Only .xlsx and .xls files are allowed", 400)
        
    file_type = request.form.get('type')
        
    if not file_type or file_type not in ['student', 'teacher']:
            return error_response("Invalid type. Must be 'student' or 'teacher'", 400)
        
    filename = secure_filename(file.filename)        
    if not os.path.exists(UPLOAD_FOLDER):
        os.makedirs(UPLOAD_FOLDER)
        
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    unique_filename = f"{file_type}_{timestamp}_{filename}"
        
    file_path = os.path.join(UPLOAD_FOLDER, unique_filename)
    file.save(file_path)
        
    is_valid, message = validate_headers(file_path, file_type)
        
    if not is_valid:
        return error_response(f"Please add the required headers. {message}", 400)
        
    if file_type == "student":
        result = process_student_file(file_path, school.id)
    else:
        result = process_teacher_file(file_path, school.id, school.stream)
        
        # Generate Excel file with added data
    excel_buffer = generate_excel_report(result, file_type, school.id)
        
        # Return Excel file as response
    return send_file(
            excel_buffer,
            mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
            as_attachment=True,
            download_name=f'{file_type}_report_{timestamp}.xlsx'
        )