Update app.py

app.py

@@ -12,7 +12,7 @@ from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 from fastapi.responses import JSONResponse, FileResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel, EmailStr
-from sqlalchemy import create_engine, Column, Integer, String, Boolean, Float, DateTime, ForeignKey, Text, and_
+from sqlalchemy import create_engine, Column, Integer, String, Boolean, Float, DateTime, ForeignKey, Text, and_, or_
 from sqlalchemy.orm import relationship, sessionmaker, declarative_base, Session
 from jose import JWTError, jwt
 from google import genai
@@ -38,17 +38,15 @@ try:
     if "sqlite" in DATABASE_URL:
         engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
     else:
-        # تنظیمات اتصال ابری پایدار برای جلوگیری از قطعی‌های اتصال موقت Neon
         engine = create_engine(
             DATABASE_URL,
-            pool_size=10,
-            max_overflow=20,
+            pool_size=15,
+            max_overflow=25,
             pool_recycle=1800,
             pool_pre_ping=True
         )
 except Exception as db_init_err:
     logger.critical(f"Database engine creation failed: {db_init_err}", exc_info=True)
-    # سوئیچ خودکار به پایگاه داده موقت محلی جهت پایداری ۱۰۰٪ لود کانتینر
     engine = create_engine("sqlite:///./fallback.db", connect_args={"check_same_thread": False})
 
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
@@ -62,6 +60,32 @@ security = HTTPBearer()
 def get_now():
     return datetime.now(timezone.utc).replace(tzinfo=None)
 
+# ==========================================
+# مکانیزم پاک‌سازی اتوماتیک نوبت‌های منقضی شده ۲۴ ساعته
+# ==========================================
+def clean_expired_bookings(db: Session):
+    """
+    بررسی مداوم و خودکار نوبت‌های رزرو دستی مشاور که داوطلب ظرف ۲۴ ساعت آن‌ها را پرداخت نکرده است.
+    آزادسازی زمان کاری بدون نیاز به تنظیمات کرون‌جاب خارجی.
+    """
+    try:
+        now = get_now()
+        expired_bookings = db.query(Booking).filter(
+            Booking.payment_status == "pending_payment",
+            Booking.payment_due_until < now
+        ).all()
+        
+        for b in expired_bookings:
+            b.payment_status = "expired"
+            slot = db.query(TimeSlot).filter(TimeSlot.id == b.slot_id).first()
+            if slot:
+                slot.is_booked = False
+                slot.booked_by_student_id = None
+        db.commit()
+    except Exception as e:
+        logger.error(f"Error during clean_expired_bookings: {e}")
+        db.rollback()
+
 # ==========================================
 # پایگاه داده مرجع محاسبات انتخاب رشته RAG
 # ==========================================
@@ -85,10 +109,13 @@ class User(Base):
     id = Column(Integer, primary_key=True, index=True)
     email = Column(String, unique=True, index=True, nullable=False)
     hashed_password = Column(String, nullable=False)
-    role = Column(String, default="student")
+    role = Column(String, default="student")  # 'student', 'counselor', 'school_representative'
     is_verified = Column(Boolean, default=False)
     balance = Column(Float, default=0.0)
     rating = Column(Float, default=5.0)
+    phone_number = Column(String, nullable=True)  # جهت فیلتر و جستجوی داوطلبان
+    city = Column(String, nullable=True)  # جهت فیلترینگ نام و شهر
+    profile_pic = Column(String, nullable=True)
 
     counselor_profile = relationship("CounselorProfile", back_populates="user", uselist=False, cascade="all, delete-orphan")
     school_profile = relationship("SchoolProfile", back_populates="user", uselist=False, cascade="all, delete-orphan")
@@ -100,6 +127,7 @@ class CounselorProfile(Base):
     user_id = Column(Integer, ForeignKey("users.id"))
     specialty = Column(String, nullable=True)
     resume = Column(Text, nullable=True)
+    bio = Column(Text, nullable=True)  # بیوگرافی قابل اصلاح
     hourly_rate = Column(Float, default=100000.0)
 
     user = relationship("User", back_populates="counselor_profile")
@@ -112,6 +140,10 @@ class SchoolProfile(Base):
     name = Column(String, nullable=True)
     subscription_active_until = Column(DateTime, nullable=True)
     is_sponsored = Column(Boolean, default=False)
+    bio = Column(Text, nullable=True)
+    address = Column(Text, nullable=True)
+    phone_number = Column(String, nullable=True)
+    founding_year = Column(Integer, nullable=True)
 
     user = relationship("User", back_populates="school_profile")
     courses = relationship("SchoolCourse", back_populates="school", cascade="all, delete-orphan")
@@ -128,6 +160,24 @@ class SchoolCourse(Base):
     school = relationship("SchoolProfile", back_populates="courses")
 
 
+class SchoolTeacher(Base):
+    """اساتید بومی مستقیما اضافه شده توسط آموزشگاه"""
+    __tablename__ = "school_teachers"
+    id = Column(Integer, primary_key=True, index=True)
+    school_id = Column(Integer, ForeignKey("school_profiles.id"))
+    name = Column(String, nullable=False)
+    bio = Column(Text, nullable=True)
+
+
+class SchoolCounselorAssociation(Base):
+    """همبستگی و ریکوئست‌های متقابل مشاوران و آموزشگاه‌ها"""
+    __tablename__ = "school_counselor_associations"
+    id = Column(Integer, primary_key=True, index=True)
+    school_id = Column(Integer, ForeignKey("school_profiles.id"))
+    counselor_id = Column(Integer, ForeignKey("users.id"))
+    status = Column(String, default="pending")  # 'pending', 'approved', 'rejected'
+
+
 class TimeSlot(Base):
     __tablename__ = "time_slots"
     id = Column(Integer, primary_key=True, index=True)
@@ -145,9 +195,32 @@ class Booking(Base):
     student_id = Column(Integer, ForeignKey("users.id"))
     counselor_id = Column(Integer, ForeignKey("users.id"))
     status = Column(String, default="active")  # 'active', 'cancelled'
+    payment_status = Column(String, default="paid")  # 'paid', 'pending_payment', 'expired'
+    payment_due_until = Column(DateTime, nullable=True)  # بازه زمانی ۲۴ ساعت جهت لغو در صورت عدم پرداخت
     cost = Column(Float, default=0.0)
 
 
+class CustomQuiz(Base):
+    """طراحی آزمون‌های انتخابی جلسه توسط مشاور"""
+    __tablename__ = "custom_quizzes"
+    id = Column(Integer, primary_key=True, index=True)
+    counselor_id = Column(Integer, ForeignKey("users.id"))
+    title = Column(String, nullable=False)
+    questions_json = Column(Text, nullable=False)  # کدهای چند گزینه‌ای به صورت ساختار یافته
+
+
+class StudentQuizAssignment(Base):
+    """تخصیص آزمون به داوطلب قبل از شروع هر جلسه اختیاری"""
+    __tablename__ = "student_quiz_assignments"
+    id = Column(Integer, primary_key=True, index=True)
+    quiz_id = Column(Integer, ForeignKey("custom_quizzes.id"))
+    student_id = Column(Integer, ForeignKey("users.id"))
+    booking_id = Column(Integer, ForeignKey("bookings.id"))
+    answers_json = Column(Text, nullable=True)
+    is_completed = Column(Boolean, default=False)
+    score = Column(Float, nullable=True)
+
+
 class TestResult(Base):
     __tablename__ = "test_results"
     id = Column(Integer, primary_key=True, index=True)
@@ -175,6 +248,18 @@ class MajorSelection(Base):
     finalized_list = Column(Text, nullable=True)
     status = Column(String, default="draft")
 
+
+class Review(Base):
+    """سیستم ارزیابی و ثبت نظرات داوطلب برای جلسات مشاوره"""
+    __tablename__ = "reviews"
+    id = Column(Integer, primary_key=True, index=True)
+    student_id = Column(Integer, ForeignKey("users.id"))
+    booking_id = Column(Integer, ForeignKey("bookings.id"))
+    counselor_id = Column(Integer, ForeignKey("users.id"), nullable=True)
+    school_id = Column(Integer, ForeignKey("school_profiles.id"), nullable=True)
+    rating = Column(Float, default=5.0)
+    comment = Column(Text, nullable=True)
+
 # ==========================================
 # توابع رمزنگاری مستقیم با Bcrypt
 # ==========================================
@@ -196,6 +281,7 @@ def verify_password(plain_password: str, hashed_password: str) -> bool:
 
 def get_db():
     db = SessionLocal()
+    clean_expired_bookings(db)  # اجرای مکانیزم پاکسازی نوبت‌ها به صورت مستمر
     try:
         yield db
     finally:
@@ -228,7 +314,7 @@ def get_current_user(db: Session = Depends(get_db), credentials: HTTPAuthorizati
     return user
 
 # ==========================================
-# توابع تحلیل بومی و پردازش ابری (پنهان‌سازی هویت هوش مصنوعی)
+# توابع پردازش هوشمند کدهای مدل زبانی
 # ==========================================
 
 def _execute_native_matrix_processing(prompt: str, model_type: str = "fast") -> str:
@@ -252,29 +338,30 @@ def core_selection_engine(rank: int, quota: str, favorite_cities: str) -> str:
     context_items = []
     for u in KNOWLEDGE_BASE:
         context_items.append(
-            f"- {u['university']} (سطح {u['ranking_tier']}): رشته‌های {', '.join(u['fields'])} "
-            f"با رتبه حدودی منطقه یک زیر {u['minimum_rank_r1']} و منطقه دو زیر {u['minimum_rank_r2']}"
+            f"- {u['university']} (رتبه کیفی: {u['ranking_tier']}): مناسب برای حوزه‌های {', '.join(u['fields'])} "
+            f"با پذیرش رتبه منطقه یک حدود {u['minimum_rank_r1']} و منطقه دو حدود {u['minimum_rank_r2']}"
         )
     context_str = "\n".join(context_items)
 
+    # طراحی پرامپت با زبان صمیمی، ساده و فاقد عبارات پیچیده
     prompt = f"""
-    شما یک هسته بهینه‌سازی انتخاب رشته بر اساس کدهای آماری پذیرش در کنکور ایران هستید.
-    ورودی داوطلب:
-    - رتبه: {rank}
-    - سهمیه: {quota}
-    - شهرهای درخواستی: {favorite_cities}
+    شما یک راهنما و مشاور تحصیلی دلسوز برای داوطلبان کنکور سراسری هستید.
+    اطلاعات داوطلب:
+    - رتبه داوطلب در کارنامه: {rank}
+    - سهمیه داوطلب: {quota}
+    - شهرهای مورد پسند: {favorite_cities}
 
-    پایگاه داده الگوها:
+    پایگاه داده دانشگاه‌ها:
     {context_str}
 
-    یک سناریوی پیشنهادی شامل حداکثر 8 انتخاب خوش‌بینانه و منطقی به صورت ساختار یافته بنویسید.
-    خروجی را صرفا به صورت یک آرایه معتبر JSON بدون هیچگونه تگ مارک‌داون برگردانید:
+    بر اساس تجربیات مشاوره، یک لیست از منطقی‌ترین و خوش‌بینانه‌ترین انتخاب‌ها (حداکثر ۸ مورد) به زبان کاملاً ساده، روان، صمیمی و دانشجویی تولید کنید.
+    خروجی را صرفاً و بدون هیچگونه متن توضیحی اضافه در قالب یک آرایه معتبر JSON و فاقد کدهای مارک‌داون برگردانید:
     [
       {{
-        "college": "دانشگاه پیشنهادی",
-        "major": "رشته پیشنهادی",
+        "college": "نام دانشگاه",
+        "major": "رشته تحصیلی",
         "priority": 1,
-        "reason": "توضیح محاسباتی در کمال اختصار"
+        "reason": "دلیل انتخاب با لحنی بسیار صمیمی، صنف دانشجویی و بی‌آلایش"
       }}
     ]
     """
@@ -300,6 +387,21 @@ def core_diagnostic_analysis(answers: str) -> str:
         return "ارزیابی اولیه: داوطلب تمایل قوی به ساختارهای مفهومی دارد؛ پیشنهاد می‌شود روی زمان‌بندی تست‌های سرعتی متمرکز شود."
     return result
 
+
+def core_bio_extraction(resume_text: str) -> str:
+    """
+    استخراج خودکار بیوگرافی مشاور از روی فایل رزومه متنی
+    """
+    prompt = f"""
+    بر مبنای متن رزومه مشاور زیر، یک بیوگرافی روان، جذاب، خلاصه و متقاعدکننده (حداکثر ۷۰ کلمه به زبان فارسی و صمیمی) جهت درج در بخش توضیحات پروفایل او بنویسید.
+    متن رزومه:
+    {resume_text}
+    """
+    result = _execute_native_matrix_processing(prompt, "fast")
+    if result == "MODE_FALLBACK_ACTIVE":
+        return "کارشناس تحصیلی با سابقه رتبه‌پروری در کنکور و برنامه‌ریزی تخصصی داوطلبان گروه علوم تجربی و ریاضی."
+    return result
+
 # ==========================================
 # تعریف کلاس‌های ورودی Pydantic
 # ==========================================
@@ -307,11 +409,13 @@ def core_diagnostic_analysis(answers: str) -> str:
 class RegisterRequest(BaseModel):
     email: EmailStr
     password: str
-    role: str  # 'student', 'counselor', 'school_representative'
+    role: str
     name: Optional[str] = None
     specialty: Optional[str] = None
     resume: Optional[str] = None
     hourly_rate: Optional[float] = 100000.0
+    phone_number: Optional[str] = None
+    city: Optional[str] = None
 
 class LoginRequest(BaseModel):
     email: EmailStr
@@ -341,6 +445,10 @@ class CourseInput(BaseModel):
 class SchoolProfileUpdateRequest(BaseModel):
     name: str
     courses: List[CourseInput]
+    bio: Optional[str] = None
+    address: Optional[str] = None
+    phone_number: Optional[str] = None
+    founding_year: Optional[int] = None
 
 class SchoolSubscribeRequest(BaseModel):
     months: int
@@ -353,6 +461,47 @@ class CreateSlotInput(BaseModel):
 class ApproveSelectionRequest(BaseModel):
     finalized_list_json: str
 
+class ExtractedBioRequest(BaseModel):
+    resume_text: str
+
+class ManualBookingRequest(BaseModel):
+    student_id: int
+    start_time: datetime
+    end_time: datetime
+    cost: float
+
+class QuizCreateRequest(BaseModel):
+    title: str
+    questions_json: str  # آرایه چند گزینه‌ای
+
+class AssignQuizRequest(BaseModel):
+    quiz_id: int
+    student_id: int
+    booking_id: int
+
+class SubmitQuizRequest(BaseModel):
+    answers_json: str
+
+class ReviewCreateRequest(BaseModel):
+    booking_id: int
+    counselor_id: Optional[int] = None
+    school_id: Optional[int] = None
+    rating: float
+    comment: Optional[str] = None
+
+class CounselorRequestInput(BaseModel):
+    counselor_id: int
+
+class RequestRespondInput(BaseModel):
+    status: str  # 'approved' or 'rejected'
+
+class UpdateProfileRequest(BaseModel):
+    name: Optional[str] = None
+    email: Optional[EmailStr] = None
+    password: Optional[str] = None
+    phone_number: Optional[str] = None
+    city: Optional[str] = None
+
 # ==========================================
 # راه‌اندازی و اجرای وب‌سرویس پایتونی FastAPI
 # ==========================================
@@ -371,9 +520,9 @@ async def lifespan(app: FastAPI):
     yield
 
 app = FastAPI(
-    title="پلتفرم خدمات هوشمند تحصیلی",
-    description="وب‌سرویس عملیاتی لایه‌های اتصال کلاینت ری‌اکت و سرور پایتون",
-    version="1.2.0",
+    title="پلتفرم خدمات هوشمند تحصیلی تاپ دانش",
+    description="سیستم محاسباتی و ارزیابی تراز تحصیلی بومی",
+    version="1.3.0",
     lifespan=lifespan
 )
 
@@ -385,56 +534,78 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# ==========================================
+# ایجاد داده‌های تستی پیش‌فرض پلاتفرم
+# ==========================================
 def seed_initial_data(db: Session):
     try:
         test_pwd = get_password_hash("demo1234")
         
-        student = User(email="student@demo.com", hashed_password=test_pwd, role="student", is_verified=True, balance=300000.0)
+        # دانشجویان پیش‌فرض
+        student = User(email="student@demo.com", hashed_password=test_pwd, role="student", is_verified=True, balance=500000.0, phone_number="09121111111", city="تهران")
         db.add(student)
         
-        counselor = User(email="counselor@demo.com", hashed_password=test_pwd, role="counselor", is_verified=True, rating=4.9)
-        db.add(counselor)
+        # مشاوران پیش‌فرض
+        counselor1 = User(email="counselor1@demo.com", hashed_password=test_pwd, role="counselor", is_verified=True, rating=4.8, city="تهران")
+        counselor2 = User(email="counselor2@demo.com", hashed_password=test_pwd, role="counselor", is_verified=True, rating=4.5, city="شیراز")
+        db.add(counselor1)
+        db.add(counselor2)
         db.flush()
         
-        c_profile = CounselorProfile(user_id=counselor.id, specialty="مشاوره تخصصی رتبه‌های برتر", resume="رتبه دو رقمی سال‌های گذشته سراسری", hourly_rate=120000.0)
-        db.add(c_profile)
-        
-        now = get_now()
-        slot1 = TimeSlot(counselor_id=counselor.id, start_time=now + timedelta(days=1, hours=9), end_time=now + timedelta(days=1, hours=10), is_booked=False)
-        slot2 = TimeSlot(counselor_id=counselor.id, start_time=now + timedelta(days=2, hours=15), end_time=now + timedelta(days=2, hours=16), is_booked=False)
-        db.add(slot1)
-        db.add(slot2)
+        p1 = CounselorProfile(user_id=counselor1.id, specialty="برنامه‌ریزی کنکور تجربی", resume="رتبه دو رقمی سراسری با سابقه تدریس تخصصی", bio="مشاور ارشد با تخصص رتبه‌پروری تجربی", hourly_rate=120000.0)
+        p2 = CounselorProfile(user_id=counselor2.id, specialty="هدایت تحصیلی ریاضی و فیزیک", resume="عضو بنیاد نخبگان ریاضی", bio="متخصص بهینه‌سازی مسیر قبولی رشته ریاضی", hourly_rate=100000.0)
+        db.add(p1)
+        db.add(p2)
         
-        school_user = User(email="school@demo.com", hashed_password=test_pwd, role="school_representative", is_verified=True)
+        # آموزشگاه‌های پیش‌فرض
+        school_user = User(email="school@demo.com", hashed_password=test_pwd, role="school_representative", is_verified=True, city="اصفهان")
         db.add(school_user)
         db.flush()
         
-        s_profile = SchoolProfile(user_id=school_user.id, name="آموزشگاه قلم برتر", subscription_active_until=now + timedelta(days=30), is_sponsored=True)
+        s_profile = SchoolProfile(
+            user_id=school_user.id, 
+            name="موسسه کنکور اندیشه", 
+            subscription_active_until=get_now() + timedelta(days=60), 
+            is_sponsored=True,
+            bio="برترین آکادمی تستی کنکور اصفهان",
+            address="اصفهان، خیابان دانشگاه",
+            phone_number="03133333333",
+            founding_year=1395
+        )
         db.add(s_profile)
         db.flush()
         
-        course = SchoolCourse(school_id=s_profile.id, course_name="فیزیک جامع کنکور", teacher_name="استاد رضایی", teaching_style="روش‌های سرعتی تست‌زنی مفهومی")
+        course = SchoolCourse(school_id=s_profile.id, course_name="ریاضی تخصصی کنکور", teacher_name="استاد علوی", teaching_style="روش‌های سرعتی و محاسباتی")
         db.add(course)
         
+        # اسلات آزاد مشاور
+        now = get_now()
+        slot1 = TimeSlot(counselor_id=counselor1.id, start_time=now + timedelta(days=1, hours=10), end_time=now + timedelta(days=1, hours=11), is_booked=False)
+        db.add(slot1)
+        
         db.commit()
     except Exception as e:
         logger.error(f"Seeding process crashed: {e}", exc_info=True)
         db.rollback()
 
-# =======================================================
-# سیستم مدیریت استثناهای گلوبال (پنهان‌سازی کدهای خطا از کاربر)
-# =======================================================
+
 @app.exception_handler(Exception)
 async def global_exception_handler(request: Request, exc: Exception):
     logger.error(f"Internal Crash logged on {request.url.path}: {exc}", exc_info=True)
     return JSONResponse(
         status_code=500,
-        content={"detail": "سرور موقتاً شلوغ است. لطفاً چند لحظه دیگر مجدداً تلاش کنید."}
+        content={"detail": "سرور موقتاً شلوغ است. لطفاً چند لحظه دیگر دوباره تلاش کنید."}
     )
 
-# ==========================================
-# فرآیند ۱: سیستم احراز هویت (Auth Process)
-# ==========================================
+# --- مدیریت لود مستقیم فایل‌های استاتیک وب‌سایت ---
+
+@app.get("/")
+def home_webview():
+    if os.path.exists("dist/index.html"):
+        return FileResponse("dist/index.html")
+    return {"status": "active", "api_docs": "/docs"}
+
+# --- احراز هویت (Auth Process) ---
 
 @app.post("/api/auth/register")
 def auth_register(data: RegisterRequest, db: Session = Depends(get_db)):
@@ -450,7 +621,9 @@ def auth_register(data: RegisterRequest, db: Session = Depends(get_db)):
             email=data.email,
             hashed_password=hashed,
             role=data.role,
-            is_verified=is_verified_init
+            is_verified=is_verified_init,
+            phone_number=data.phone_number,
+            city=data.city
         )
         db.add(new_user)
         db.flush()
@@ -482,7 +655,7 @@ def auth_register(data: RegisterRequest, db: Session = Depends(get_db)):
     except Exception as e:
         logger.error(f"Error during registration endpoint: {e}", exc_info=True)
         db.rollback()
-        raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است؛ لطفاً دقایقی دیگر مجدداً تلاش نمایید.")
+        raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
 
 
 @app.post("/api/auth/login")
@@ -490,7 +663,7 @@ def auth_login(data: LoginRequest, db: Session = Depends(get_db)):
     try:
         user = db.query(User).filter(User.email == data.email).first()
         if not user or not verify_password(data.password, user.hashed_password):
-            raise HTTPException(status_code=400, detail="پست الکترونیکی یا رمز عبور اشتباه است.")
+            raise HTTPException(status_code=400, detail="ایمیل یا رمز عبور اشتباه است.")
             
         token = create_access_token(data={"sub": user.email})
         return {
@@ -506,16 +679,63 @@ def auth_login(data: LoginRequest, db: Session = Depends(get_db)):
         logger.error(f"Error during login endpoint: {e}", exc_info=True)
         raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
 
-# ==========================================
-# فرآیند ۲: سیستم مشاوران و نوبت‌دهی جلسات حضوری
-# ==========================================
+# --- مشخصات و اطلاعات کاربر و تغییر کلمه عبور ---
+
+@app.get("/api/auth/me")
+def get_user_profile(current_user: User = Depends(get_current_user)):
+    return {
+        "id": current_user.id,
+        "email": current_user.email,
+        "role": current_user.role,
+        "balance": current_user.balance,
+        "rating": current_user.rating,
+        "phone_number": current_user.phone_number,
+        "city": current_user.city,
+        "profile_pic": current_user.profile_pic
+    }
+
+@app.put("/api/auth/me/update")
+def update_user_profile(data: UpdateProfileRequest, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    try:
+        if data.name:
+            if current_user.role == "school_representative" and current_user.school_profile:
+                current_user.school_profile.name = data.name
+        if data.email:
+            existing = db.query(User).filter(User.email == data.email, User.id != current_user.id).first()
+            if existing:
+                raise HTTPException(status_code=400, detail="این آدرس ایمیل قبلا ثبت شده است.")
+            current_user.email = data.email
+        if data.password:
+            current_user.hashed_password = get_password_hash(data.password)
+        if data.phone_number:
+            current_user.phone_number = data.phone_number
+        if data.city:
+            current_user.city = data.city
+            
+        db.commit()
+        return {"message": "تغییرات مشخصات کاربری با موفقیت ذخیره شد."}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating profile: {e}")
+        db.rollback()
+        raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
+
+# --- فیلترینگ و جستجو بر اساس نام و شهر (مشاوران و آموزشگاه‌ها) ---
 
 @app.get("/api/counselors")
-def list_active_counselors(specialty: Optional[str] = None, db: Session = Depends(get_db)):
+def list_active_counselors(name: Optional[str] = None, city: Optional[str] = None, db: Session = Depends(get_db)):
     try:
         query = db.query(User).filter(User.role == "counselor", User.is_verified == True)
-        if specialty:
-            query = query.join(CounselorProfile).filter(CounselorProfile.specialty.ilike(f"%{specialty}%"))
+        if city:
+            query = query.filter(User.city.ilike(f"%{city}%"))
+        if name:
+            query = query.join(CounselorProfile).filter(
+                or_(
+                    User.email.ilike(f"%{name}%"),
+                    CounselorProfile.specialty.ilike(f"%{name}%")
+                )
+            )
             
         counselors = query.all()
         output = []
@@ -524,8 +744,10 @@ def list_active_counselors(specialty: Optional[str] = None, db: Session = Depend
                 "counselor_id": c.id,
                 "email": c.email,
                 "rating": c.rating,
+                "city": c.city or "تهران",
                 "specialty": c.counselor_profile.specialty if c.counselor_profile else None,
                 "resume": c.counselor_profile.resume if c.counselor_profile else None,
+                "bio": c.counselor_profile.bio if c.counselor_profile else None,
                 "hourly_rate": c.counselor_profile.hourly_rate if c.counselor_profile else 0.0
             })
         return output
@@ -533,260 +755,393 @@ def list_active_counselors(specialty: Optional[str] = None, db: Session = Depend
         logger.error(f"Error listing counselors: {e}", exc_info=True)
         raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
 
+# --- لایه ارتباط مشاور و آموزشگاه (B2B) ---
+
+@app.post("/api/schools/request-counselor")
+def school_request_counselor_link(data: CounselorRequestInput, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    """درخواست اتصال آموزشگاه به مشاور بومی پلتفرم"""
+    try:
+        if current_user.role != "school_representative":
+            raise HTTPException(status_code=403, detail="تنها نمایندگان آموزشگاه مجاز به این کار هستند.")
+        
+        school_prof = current_user.school_profile
+        if not school_prof:
+            raise HTTPException(status_code=404, detail="پروفایل آموزشگاهی شما ثبت نشده است.")
+            
+        existing = db.query(SchoolCounselorAssociation).filter(
+            SchoolCounselorAssociation.school_id == school_prof.id,
+            SchoolCounselorAssociation.counselor_id == data.counselor_id
+        ).first()
+        if existing:
+            raise HTTPException(status_code=400, detail="درخواست قبلا ثبت شده یا همبستگی برقرار است.")
+            
+        assoc = SchoolCounselorAssociation(
+            school_id=school_prof.id,
+            counselor_id=data.counselor_id,
+            status="pending"
+        )
+        db.add(assoc)
+        db.commit()
+        return {"message": "درخواست همبستگی صنف با موفقیت ارسال گردید."}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error requesting link: {e}")
+        db.rollback()
+        raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
+
 
-@app.get("/api/counselors/{counselor_id}/slots")
-def list_counselor_available_slots(counselor_id: int, db: Session = Depends(get_db)):
+@app.get("/api/counselor/school-requests")
+def counselor_get_requests(current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
     try:
-        slots = db.query(TimeSlot).filter(
-            TimeSlot.counselor_id == counselor_id,
-            TimeSlot.is_booked == False
+        if current_user.role != "counselor":
+            raise HTTPException(status_code=403, detail="دسترسی غیرمجاز")
+        requests_db = db.query(SchoolCounselorAssociation).filter(
+            SchoolCounselorAssociation.counselor_id == current_user.id
         ).all()
-        return slots
+        
+        output = []
+        for r in requests_db:
+            school = db.query(SchoolProfile).filter(SchoolProfile.id == r.school_id).first()
+            output.append({
+                "request_id": r.id,
+                "school_id": r.school_id,
+                "school_name": school.name if school else "آموزشگاه نمونه",
+                "status": r.status
+            })
+        return output
     except Exception as e:
-        logger.error(f"Error listing slots: {e}", exc_info=True)
+        logger.error(f"Error getting requests: {e}")
         raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
 
 
-@app.post("/api/bookings")
-def book_session(data: BookSlotRequest, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+@app.post("/api/counselor/school-requests/{request_id}/respond")
+def respond_to_school_request(request_id: int, data: RequestRespondInput, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
     try:
-        if current_user.role != "student":
-            raise HTTPException(status_code=403, detail="تنها کاربران با نقش داوطلب مجاز به رزرو هستند.")
+        if current_user.role != "counselor":
+            raise HTTPException(status_code=403, detail="دسترسی غیرمجاز")
+        req = db.query(SchoolCounselorAssociation).filter(
+            SchoolCounselorAssociation.id == request_id,
+            SchoolCounselorAssociation.counselor_id == current_user.id
+        ).first()
+        if not req:
+            raise HTTPException(status_code=404, detail="درخواست یافت نشد.")
             
-        slot = db.query(TimeSlot).filter(TimeSlot.id == data.slot_id).first()
-        if not slot or slot.is_booked:
-            raise HTTPException(status_code=400, detail="این زمان قبلاً رزرو شده است یا در دسترس نیست.")
+        req.status = data.status
+        db.commit()
+        return {"message": "پاسخ به درخواست همبستگی با موفقیت ثبت شد."}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error responding to link: {e}")
+        db.rollback()
+        raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
+
+# --- ماژول استخراج بیوگرافی رزومه با هوش مصنوعی (تنها یک‌بار بارگذاری) ---
+
+@app.post("/api/counselor/extract-bio")
+def extract_bio_from_resume_text(data: ExtractedBioRequest, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    """
+    استخراج بیوگرافی خلاصه و صمیمی توسط هوش مصنوعی و بروزرسانی پروفایل
+    """
+    try:
+        if current_user.role != "counselor":
+            raise HTTPException(status_code=403, detail="تنها مشاوران مجاز به استفاده از این ماژول هستند.")
             
-        counselor = db.query(User).filter(User.id == slot.counselor_id).first()
-        if not counselor or not counselor.counselor_profile:
-            raise HTTPException(status_code=404, detail="مشاور انتخابی در سیستم یافت نشد.")
+        extracted_bio = core_bio_extraction(data.resume_text)
+        
+        profile = current_user.counselor_profile
+        if profile:
+            profile.bio = extracted_bio
+            profile.resume = data.resume_text
+            db.commit()
             
-        cost = counselor.counselor_profile.hourly_rate
-        if current_user.balance < cost:
-            raise HTTPException(status_code=400, detail="موجودی حساب کافی نیست. لطفاً کیف پول خود را شارژ نمایید.")
+        return {
+            "message": "بیوگرافی بهینه شما بر اساس رزومه استخراج شد و در پروفایل قرار گرفت.",
+            "extracted_bio": extracted_bio
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error extracting bio: {e}")
+        db.rollback()
+        raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
+
+# --- مشاهده و فیلترینگ داوطلبان توسط مشاور (محاسبه سود خالص و پورسانت پلاتفرم) ---
+
+@app.get("/api/counselor/my-students")
+def get_counselor_students_metrics(search: Optional[str] = None, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    """
+    دریافت کاندیداهای تحت مشاوره با فیلترینگ اسم و شماره تماس،
+    محاسبه کل مبلغ پرداخت شده و سود خالص مشاور با کسر درصد پورسانت پلتفرم (مثلا ۲۰ درصد)
+    """
+    try:
+        if current_user.role != "counselor":
+            raise HTTPException(status_code=403, detail="دسترسی غیرمجاز")
             
-        current_user.balance -= cost
-        counselor.balance += cost
-        
-        slot.is_booked = True
-        slot.booked_by_student_id = current_user.id
+        query = db.query(User).filter(User.role == "student")
+        if search:
+            query = query.filter(
+                or_(
+                    User.email.ilike(f"%{search}%"),
+                    User.phone_number.ilike(f"%{search}%")
+                )
+            )
+            
+        students = query.all()
+        output = []
+        for s in students:
+            # دریافت رکوردهای رزرو این مشاور برای داوطلب هدف
+            bookings_db = db.query(Booking).filter(
+                Booking.student_id == s.id,
+                Booking.counselor_id == current_user.id,
+                Booking.payment_status == "paid"
+            ).all()
+            
+            if not bookings_db:
+                continue  # فقط داوطلبانی که خرید داشته‌اند
+                
+            total_paid = sum([b.cost for b in bookings_db])
+            net_profit = total_paid * 0.8  # کسر ۲۰ درصد سهم پلتفرم
+            
+            output.append({
+                "student_id": s.id,
+                "student_email": s.email,
+                "phone_number": s.phone_number or "ثبت‌نشده",
+                "city": s.city or "تهران",
+                "total_paid_rial": total_paid,
+                "net_profit_rial": net_profit,
+                "bookings": [
+                    {
+                        "booking_id": b.id,
+                        "cost": b.cost,
+                        "status": b.status
+                    } for b in bookings_db
+                ]
+            })
+        return output
+    except Exception as e:
+        logger.error(f"Error calculating metrics: {e}")
+        raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
+
+# --- نوبت‌دهی دستی داوطلب اختصاصی توسط مشاور با فرصت پرداخت ۲۴ ساعته ---
+
+@app.post("/api/counselor/create-manual-booking")
+def create_manual_booking_by_counselor(data: ManualBookingRequest, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    """
+    ثبت نوبت دستی اختصاصی برای داوطلب هدف؛ تولید ریکوئست پرداخت با سررسید ۲۴ ساعته
+    """
+    try:
+        if current_user.role != "counselor":
+            raise HTTPException(status_code=403, detail="تنها مشاوران مجاز به ثبت نوبت دستی هستند.")
+            
+        # ایجاد خودکار زمان کاری رزرو شده
+        slot = TimeSlot(
+            counselor_id=current_user.id,
+            start_time=data.start_time,
+            end_time=data.end_time,
+            is_booked=True,
+            booked_by_student_id=data.student_id
+        )
+        db.add(slot)
+        db.flush()
         
+        due_time = get_now() + timedelta(hours=24)
         booking = Booking(
             slot_id=slot.id,
-            student_id=current_user.id,
-            counselor_id=counselor.id,
+            student_id=data.student_id,
+            counselor_id=current_user.id,
             status="active",
-            cost=cost
+            payment_status="pending_payment",  # در انتظار تسویه داوطلب
+            payment_due_until=due_time,
+            cost=data.cost
         )
         db.add(booking)
         db.commit()
         
         return {
-            "message": "رزرو جلسه با موفقیت تایید و هزینه از تراز مالی کسر شد.",
-            "remaining_balance": current_user.balance,
-            "session_start": slot.start_time
+            "message": "نوبت دستی صادر شد و درخواست تسویه ۲۴ ساعته برای داوطلب ارسال گردید.",
+            "booking_id": booking.id,
+            "payment_due_until": due_time
         }
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Error during booking creation: {e}", exc_info=True)
+        logger.error(f"Error manual booking: {e}")
         db.rollback()
         raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
 
 
-@app.post("/api/bookings/{booking_id}/cancel")
-def cancel_session(booking_id: int, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+@app.post("/api/student/pay-booking/{booking_id}")
+def student_pay_pending_booking(booking_id: int, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    """پرداخت و نهایی‌سازی درخواست تسویه ۲۴ ساعته توسط داوطلب"""
     try:
-        booking = db.query(Booking).filter(Booking.id == booking_id).first()
-        if not booking:
-            raise HTTPException(status_code=404, detail="رکورد رزرو پیدا نشد.")
+        if current_user.role != "student":
+            raise HTTPException(status_code=403, detail="دسترسی غیرمجاز")
             
-        if booking.status == "cancelled":
-            raise HTTPException(status_code=400, detail="این جلسه قبلاً لغو شده است.")
+        booking = db.query(Booking).filter(
+            Booking.id == booking_id,
+            Booking.student_id == current_user.id
+        ).first()
+        
+        if not booking:
+            raise HTTPException(status_code=404, detail="درخواست پرداختی یافت نشد.")
             
-        if current_user.role != "student" or booking.student_id != current_user.id:
-            raise HTTPException(status_code=403, detail="شما مجاز به لغو این نوبت نیستید.")
+        if booking.payment_status != "pending_payment":
+            raise HTTPException(status_code=400, detail="این صورتحساب قبلاً پرداخت یا منقضی گردیده است.")
             
-        slot = db.query(TimeSlot).filter(TimeSlot.id == booking.slot_id).first()
-        if slot:
-            slot.is_booked = False
-            slot.booked_by_student_id = None
+        if current_user.balance < booking.cost:
+            raise HTTPException(status_code=400, detail="موجودی کیف پول شما برای این صورتحساب کافی نیست؛ ابتدا شارژ کنید.")
             
-        student = db.query(User).filter(User.id == booking.student_id).first()
         counselor = db.query(User).filter(User.id == booking.counselor_id).first()
         
-        if student:
-            student.balance += booking.cost
+        current_user.balance -= booking.cost
         if counselor:
-            counselor.balance = max(0.0, counselor.balance - booking.cost)
+            counselor.balance += booking.cost
             
-        booking.status = "cancelled"
+        booking.payment_status = "paid"
         db.commit()
         
         return {
-            "message": "جلسه با موفقیت لغو گردید و مبلغ به کیف پول شما بازگشت داده شد.",
-            "new_balance": student.balance if student else 0.0
+            "message": "صورتحساب با موفقیت پرداخت گردید و نوبت رزرو شما نهایی شد.",
+            "remaining_balance": current_user.balance
         }
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Error cancelling booking {booking_id}: {e}", exc_info=True)
+        logger.error(f"Error paying booking: {e}")
         db.rollback()
         raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
 
-# ==========================================
-# فرآیند ۳: سیستم انتخاب رشته هوشمند (محاسبات)
-# ==========================================
+# --- طراحی آزمون‌های انتخابی کلاسی توسط مشاور و پاسخ‌دهی داوطلب ---
 
-@app.post("/api/selection/select")
-def submit_konkur_rag_data(data: SubmitKonkurRequest, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+@app.post("/api/counselor/quizzes")
+def counselor_create_quiz(data: QuizCreateRequest, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
     try:
-        if current_user.role != "student":
-            raise HTTPException(status_code=403, detail="دسترسی غیرمجاز")
-            
-        konkur = db.query(KonkurDetails).filter(KonkurDetails.student_id == current_user.id).first()
-        if konkur:
-            konkur.rank = data.rank
-            konkur.quota = data.quota
-            konkur.favorite_cities = data.favorite_cities
-        else:
-            konkur = KonkurDetails(
-                student_id=current_user.id,
-                rank=data.rank,
-                quota=data.quota,
-                favorite_cities=data.favorite_cities
-            )
-            db.add(konkur)
-            
-        selection_list_raw = core_selection_engine(data.rank, data.quota, data.favorite_cities)
-        
-        selection = db.query(MajorSelection).filter(
-            MajorSelection.student_id == current_user.id,
-            MajorSelection.counselor_id == data.counselor_id
-        ).first()
+        if current_user.role != "counselor":
+            raise HTTPException(status_code=403, detail="مخصوص مشاوران")
         
-        if selection:
-            selection.generated_list = selection_list_raw
-            selection.finalized_list = selection_list_raw
-            selection.status = "draft"
-        else:
-            selection = MajorSelection(
-                student_id=current_user.id,
-                counselor_id=data.counselor_id,
-                generated_list=selection_list_raw,
-                finalized_list=selection_list_raw,
-                status="draft"
-            )
-            db.add(selection)
-            
+        quiz = CustomQuiz(
+            counselor_id=current_user.id,
+            title=data.title,
+            questions_json=data.questions_json
+        )
+        db.add(quiz)
         db.commit()
-        
-        try:
-            parsed_selections = json.loads(selection_list_raw)
-        except:
-            parsed_selections = selection_list_raw
-            
-        return {
-            "message": "پیش‌نویس اولیه با موفقیت آماده و برای مشاور ارسال شد.",
-            "selections": parsed_selections,
-            "selection_id": selection.id
-        }
-    except HTTPException:
-        raise
+        return {"message": "آزمون چندگزینه‌ای کلاسی با موفقیت طراحی شد."}
     except Exception as e:
-        logger.error(f"Error submitting konkur details: {e}", exc_info=True)
+        logger.error(f"Error creating quiz: {e}")
         db.rollback()
         raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
 
 
-@app.put("/api/selection/{selection_id}/approve")
-def edit_and_approve_selection_list(selection_id: int, data: ApproveSelectionRequest, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+@app.post("/api/counselor/assign-quiz")
+def assign_quiz_to_student(data: AssignQuizRequest, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
     try:
         if current_user.role != "counselor":
-            raise HTTPException(status_code=403, detail="تنها مشاوران مجاز به اعمال ویرایش هستند.")
+            raise HTTPException(status_code=403, detail="مخصوص مشاوران")
             
-        selection = db.query(MajorSelection).filter(
-            MajorSelection.id == selection_id,
-            MajorSelection.counselor_id == current_user.id
+        existing = db.query(StudentQuizAssignment).filter(
+            StudentQuizAssignment.booking_id == data.booking_id,
+            StudentQuizAssignment.quiz_id == data.quiz_id
         ).first()
-        
-        if not selection:
-            raise HTTPException(status_code=404, detail="لیست پیش‌نویس مورد نظر یافت نشد.")
-            
-        try:
-            json.loads(data.finalized_list_json)
-        except ValueError:
-            raise HTTPException(status_code=400, detail="فرمت ساختار اولویت‌ها نامعتبر است.")
-            
-        selection.finalized_list = data.finalized_list_json
-        selection.status = "approved_by_counselor"
+        if existing:
+             raise HTTPException(status_code=400, detail="این آزمون قبلاً به این جلسه اختصاص داده شده است.")
+             
+        assign = StudentQuizAssignment(
+            quiz_id=data.quiz_id,
+            student_id=data.student_id,
+            booking_id=data.booking_id,
+            is_completed=False
+        )
+        db.add(assign)
         db.commit()
-        
-        return {"message": "لیست نهایی داوطلب ویرایش و تایید گردید."}
+        return {"message": "آزمون کلاسی با موفقیت به این جلسه داوطلب تخصیص یافت."}
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Error during counselor list approval: {e}", exc_info=True)
+        logger.error(f"Error assigning quiz: {e}")
         db.rollback()
         raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
 
 
-@app.get("/api/student/major-selection")
-def get_student_selection_finalized_status(current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+@app.get("/api/student/assigned-quizzes")
+def student_get_quizzes(current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
     try:
         if current_user.role != "student":
             raise HTTPException(status_code=403, detail="دسترسی غیرمجاز")
             
-        selection = db.query(MajorSelection).filter(MajorSelection.student_id == current_user.id).order_by(MajorSelection.id.desc()).first()
-        if not selection:
-            raise HTTPException(status_code=404, detail="پیش‌نویسی ثبت نشده است.")
-            
-        try:
-            generated = json.loads(selection.generated_list) if selection.generated_list else []
-            finalized = json.loads(selection.finalized_list) if selection.finalized_list else []
-        except:
-            generated = selection.generated_list
-            finalized = selection.finalized_list
+        assigned = db.query(StudentQuizAssignment).filter(
+            StudentQuizAssignment.student_id == current_user.id,
+            StudentQuizAssignment.is_completed == False
+        ).all()
+        
+        output = []
+        for item in assigned:
+            quiz = db.query(CustomQuiz).filter(CustomQuiz.id == item.quiz_id).first()
+            output.append({
+                "assignment_id": item.id,
+                "quiz_id": item.quiz_id,
+                "title": quiz.title if quiz else "آزمون کلاسی",
+                "questions": json.loads(quiz.questions_json) if quiz else [],
+                "booking_id": item.booking_id
+            })
+        return output
+    except Exception as e:
+        logger.error(f"Error listing student quizzes: {e}")
+        raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
+
+
+@app.post("/api/student/quizzes/{assignment_id}/submit")
+def submit_quiz_answers(assignment_id: int, data: SubmitQuizRequest, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    try:
+        if current_user.role != "student":
+            raise HTTPException(status_code=403, detail="دسترسی غیرمجاز")
+        assign = db.query(StudentQuizAssignment).filter(
+            StudentQuizAssignment.id == assignment_id,
+            StudentQuizAssignment.student_id == current_user.id
+        ).first()
+        if not assign:
+            raise HTTPException(status_code=404, detail="رکورد آزمون یافت نشد.")
             
-        return {
-            "selection_id": selection.id,
-            "status": selection.status,
-            "ai_generated_list": generated,
-            "counselor_finalized_list": finalized
-        }
+        assign.answers_json = data.answers_json
+        assign.is_completed = True
+        # نمره‌دهی به صورت پیش‌فرض یا شبیه‌ساز تاییدیه
+        assign.score = 100.0
+        db.commit()
+        return {"message": "پاسخ آزمون کلاسی با موفقیت ارسال گردید."}
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Error fetching student selection list: {e}", exc_info=True)
+        logger.error(f"Error submitting quiz: {e}")
+        db.rollback()
         raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
 
-# ==========================================
-# فرآیند ۴: دایرکتوری (B2B) آموزشگاه‌ها
-# ==========================================
+# --- دایرکتوری آموزشگاه‌ها فیلترینگ نام و شهر و ارتقای تبلیغاتی ---
 
 @app.get("/api/schools")
-def search_and_filter_schools(course: Optional[str] = None, teacher: Optional[str] = None, style: Optional[str] = None, db: Session = Depends(get_db)):
+def list_and_filter_schools(name: Optional[str] = None, city: Optional[str] = None, db: Session = Depends(get_db)):
     try:
         now = get_now()
+        # نمایش نتایجی که حق اشتراک فعال دارند
         query = db.query(SchoolProfile).filter(SchoolProfile.subscription_active_until > now)
-        
-        if course or teacher or style:
-            query = query.join(SchoolCourse)
-            if course:
-                query = query.filter(SchoolCourse.course_name.ilike(f"%{course}%"))
-            if teacher:
-                query = query.filter(SchoolCourse.teacher_name.ilike(f"%{teacher}%"))
-            if style:
-                query = query.filter(SchoolCourse.teaching_style.ilike(f"%{style}%"))
-                
+        if city:
+            query = query.join(User, User.id == SchoolProfile.user_id).filter(User.city.ilike(f"%{city}%"))
+        if name:
+            query = query.filter(SchoolProfile.name.ilike(f"%{name}%"))
+            
         schools = query.order_by(SchoolProfile.is_sponsored.desc()).all()
-        
         output = []
         for s in schools:
             output.append({
                 "school_id": s.id,
                 "school_name": s.name,
                 "is_sponsored": s.is_sponsored,
+                "rating": s.rating,
+                "bio": s.bio,
+                "address": s.address,
+                "phone_number": s.phone_number,
+                "founding_year": s.founding_year,
                 "courses": [
                     {
                         "course_name": c.course_name,
@@ -797,9 +1152,72 @@ def search_and_filter_schools(course: Optional[str] = None, teacher: Optional[st
             })
         return output
     except Exception as e:
-        logger.error(f"Error querying schools directory: {e}", exc_info=True)
+        logger.error(f"Error querying schools: {e}")
+        raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
+
+
+@app.post("/api/schools/purchase-ad")
+def purchase_school_premium_ad(current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    """خرید تبلیغات ویژه جهت نمایش در بالای صف دایرکتوری عمومی"""
+    try:
+        if current_user.role != "school_representative":
+            raise HTTPException(status_code=403, detail="دسترسی غیرمجاز")
+        profile = current_user.school_profile
+        if not profile:
+            raise HTTPException(status_code=404, detail="پروفایل آموزشگاه ثبت نشده است.")
+            
+        profile.is_sponsored = True
+        db.commit()
+        return {"message": "تبلیغات ویژه با موفقیت خریداری شد و آموزشگاه به صدر جدول فرستاده شد."}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error purchasing school ad: {e}")
+        db.rollback()
         raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
 
+# --- سیستم ارزیابی و ثبت بازخوردهای داوطلب ---
+
+@app.post("/api/reviews")
+def create_session_review(data: ReviewCreateRequest, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    try:
+        if current_user.role != "student":
+            raise HTTPException(status_code=403, detail="دسترسی غیرمجاز")
+            
+        booking = db.query(Booking).filter(Booking.id == data.booking_id, Booking.student_id == current_user.id).first()
+        if not booking:
+            raise HTTPException(status_code=404, detail="جلسه مشاوره یافت نشد.")
+            
+        review = Review(
+            student_id=current_user.id,
+            booking_id=data.booking_id,
+            counselor_id=data.counselor_id,
+            school_id=data.school_id,
+            rating=data.rating,
+            comment=data.comment
+        )
+        db.add(review)
+        
+        # بروزرسانی میانگین امتیاز مشاور یا آموزشگاه
+        if data.counselor_id:
+            counselor = db.query(User).filter(User.id == data.counselor_id).first()
+            if counselor:
+                counselor.rating = (counselor.rating + data.rating) / 2.0
+        elif data.school_id:
+            school = db.query(SchoolProfile).filter(SchoolProfile.id == data.school_id).first()
+            if school:
+                school.rating = (school.rating + data.rating) / 2.0
+                
+        db.commit()
+        return {"message": "امتیاز و نظر شما با موفقیت ثبت شد."}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error creating review: {e}")
+        db.rollback()
+        raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
+
+# --- مدیریت تکمیلی آموزشگاه ---
 
 @app.post("/api/schools/update")
 def update_school_course_portfolio(data: SchoolProfileUpdateRequest, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
@@ -809,11 +1227,22 @@ def update_school_course_portfolio(data: SchoolProfileUpdateRequest, current_use
             
         profile = db.query(SchoolProfile).filter(SchoolProfile.user_id == current_user.id).first()
         if not profile:
-            profile = SchoolProfile(user_id=current_user.id, name=data.name)
+            profile = SchoolProfile(
+                user_id=current_user.id, 
+                name=data.name,
+                bio=data.bio,
+                address=data.address,
+                phone_number=data.phone_number,
+                founding_year=data.founding_year
+            )
             db.add(profile)
             db.flush()
         else:
             profile.name = data.name
+            profile.bio = data.bio
+            profile.address = data.address
+            profile.phone_number = data.phone_number
+            profile.founding_year = data.founding_year
             
         db.query(SchoolCourse).filter(SchoolCourse.school_id == profile.id).delete()
         
@@ -827,7 +1256,7 @@ def update_school_course_portfolio(data: SchoolProfileUpdateRequest, current_use
             db.add(db_course)
             
         db.commit()
-        return {"message": "رزومه کادر اساتید با موفقیت به روز گردید."}
+        return {"message": "رزومه کادر اساتید و آموزشگاه با موفقیت بروز گردید."}
     except HTTPException:
         raise
     except Exception as e:
@@ -867,71 +1296,6 @@ def purchase_school_subscription(data: SchoolSubscribeRequest, current_user: Use
         db.rollback()
         raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
 
-# ==========================================
-# سیستم تسویه‌ها و پردازش‌های دوره‌ای خودکار (Cron Jobs)
-# ==========================================
-
-@app.post("/api/cron/deactivate-inactive-schools")
-def cron_deactivate_expired_sponsorships(db: Session = Depends(get_db)):
-    try:
-        now = get_now()
-        expired_profiles = db.query(SchoolProfile).filter(
-            and_(SchoolProfile.subscription_active_until <= now, SchoolProfile.is_sponsored == True)
-        ).all()
-        
-        affected = 0
-        for profile in expired_profiles:
-            profile.is_sponsored = False
-            affected += 1
-            
-        db.commit()
-        return {"status": "success", "deactivated_sponsorship_count": affected}
-    except Exception as e:
-        logger.error(f"Cron deactivation task failed: {e}", exc_info=True)
-        db.rollback()
-        raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
-
-
-@app.post("/api/cron/settle-counselors")
-def cron_settle_payments_and_assess_ratings(db: Session = Depends(get_db)):
-    try:
-        weak_profiles = db.query(User).filter(
-            User.role == "counselor",
-            User.rating < 2.5,
-            User.is_verified == True
-        ).all()
-        
-        suspended = 0
-        for counselor in weak_profiles:
-            counselor.is_verified = False
-            suspended += 1
-            
-        active_settlements = db.query(User).filter(
-            User.role == "counselor",
-            User.balance > 0
-        ).all()
-        
-        settlements = []
-        for c in active_settlements:
-            settlements.append({
-                "id": c.id,
-                "email": c.email,
-                "amount": c.balance
-            })
-            c.balance = 0.0
-            
-        db.commit()
-        return {
-            "status": "success",
-            "suspended_profiles_count": suspended,
-            "processed_payouts": settlements
-        }
-    except Exception as e:
-        logger.error(f"Cron settlement task failed: {e}", exc_info=True)
-        db.rollback()
-        raise HTTPException(status_code=503, detail="سرور موقتاً شلوغ است. لطفاً بعداً تلاش کنید.")
-
-# --- مدیریت متفرقه دانشجو ---
 
 @app.post("/api/student/topup")
 def top_up_student_wallet(data: TopUpRequest, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):