fetcher.py

import logging
from bs4 import BeautifulSoup
from concurrent.futures import ThreadPoolExecutor
from flask import g, has_request_context

logger = logging.getLogger('SchoolGradesServer.Fetcher')

def _mask_user_id(user_id: str) -> str:
    if not user_id:
        return "Unknown"
    s = str(user_id)
    if len(s) > 3:
        return s[:3] + "***"
    return "***"

def _parse_year_term(year_value, default_year="114", default_term="1"):
    try:
        s = str(year_value)
        if "_" in s:
            return s.split("_", 1)
        if len(s) >= 4:
            return s[:-1], s[-1]
    except Exception:
        pass
    return default_year, default_term

def _log(level: str, user_id: str, msg: str, req_id: str = None):
    if not req_id and has_request_context() and 'request_id' in g:
        req_id = g.request_id
    
    r_str = f"[{req_id}] " if req_id else ""
    u_str = f"[User:{_mask_user_id(user_id)}] " if user_id else ""
    
    final_msg = f"{r_str}{u_str}{msg}"
    if level == 'error':
        logger.error(final_msg)
    else:
        logger.info(final_msg)

# Note: InsecureRequestWarning is not disabled here; the HTTP session enforces SSL verification.

class GradeFetcher:
    BASE = "https://shcloud2.k12ea.gov.tw/CLHSTYC"
    LOGIN_PAGE = f"{BASE}/Auth/Auth/CloudLogin"
    DO_CHECK = f"{BASE}/Auth/Auth/DoCloudLoginCheck"
    GRADES_PAGE = f"{BASE}/ICampus/StudentInfo/Index?page=%E6%88%90%E7%B8%BE%E6%9F%A5%E8%A9%A2"
    API_BASE = f"{BASE}/ICampus"

    def __init__(self, session_factory=None):
        if session_factory is None:
            # Delay import to avoid circular dependency if any, or just use the injected one
            from app.services.http_client import get_http_session
            self.session_factory = get_http_session
        else:
            self.session_factory = session_factory

    def _get_hidden_token(self, html: str) -> str:
        """Extract __RequestVerificationToken from HTML."""
        soup = BeautifulSoup(html, "html.parser")
        el = soup.select_one('input[name="__RequestVerificationToken"]')
        if not el or not el.get("value"):
            raise RuntimeError("找不到 __RequestVerificationToken hidden input")
        return el["value"]

    def login_and_get_tokens(self, username, password):
        """Login via requests session, return (success, message, cookies_dict, student_no, token)."""
        try:
            _log('info', username, "Attempting login (requests mode)")
            s = self.session_factory()

            # 1) GET login page to obtain cookies + hidden token
            r = s.get(self.LOGIN_PAGE)
            r.raise_for_status()
            login_token = self._get_hidden_token(r.text)

            # 2) POST login
            headers = {
                "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
                "Referer": GradeFetcher.LOGIN_PAGE,
                "Origin": "https://shcloud2.k12ea.gov.tw",
                "X-Requested-With": "XMLHttpRequest",
            }
            data = {
                "SchoolCode": "030305",
                "LoginId": username,
                "PassString": password,
                "LoginType": "Student",
                "IsKeepLogin": "false",
                "IdentityId": "6",
                "SchoolName": "國立中大壢中",
                "GoogleToken": "8",
                "isRegistration": "false",
                "ShCaptchaGenCode": "10",
                "__RequestVerificationToken": login_token,
            }

            resp = s.post(self.DO_CHECK, data=data, headers=headers)
            resp.raise_for_status()

            try:
                j = resp.json()
            except Exception:
                return False, "登入回應格式錯誤", None, None, None

            ok = bool(j.get("Result", {}).get("IsLoginSuccess"))
            if not ok:
                msg = j.get("Result", {}).get("DisplayMsg") or j.get("Message") or "登入失敗"
                return False, msg, None, None, None

            _log('info', username, "Login OK, fetching grades page for API token...")

            # 3) GET grades page to obtain the API-specific __RequestVerificationToken
            r2 = s.get(self.GRADES_PAGE)
            r2.raise_for_status()
            api_token = self._get_hidden_token(r2.text)

            # 4) Extract cookies as dict (filter out malformed cookies like 'no-cache')
            cookies_dict = {}
            for c in s.cookies:
                try:
                    if c.name and c.value is not None and c.domain is not None:
                        cookies_dict[c.name] = c.value
                except Exception:
                    pass
            student_no = username

            _log('info', student_no, f"Successfully obtained credentials for {student_no}")
            return True, "登入成功", cookies_dict, student_no, api_token

        except Exception as e:
            _log('error', username, f"Login Exception: {e}")
            return False, "登入錯誤: 伺服器內部錯誤", None, None, None

    def get_structure_via_api(self, cookies, student_no, token, session=None):
        """Fetch structure using requests"""
        url = "https://shcloud2.k12ea.gov.tw/CLHSTYC/ICampus/CommonData/GetGradeCanQueryYearTermListByStudentNo"
        headers = {
            "Accept": "*/*",
            "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            "X-Requested-With": "XMLHttpRequest",
            "Origin": "https://shcloud2.k12ea.gov.tw",
            "Referer": "https://shcloud2.k12ea.gov.tw/CLHSTYC/ICampus/StudentInfo/Index?page=%E6%88%90%E7%B8%BE%E6%9F%A5%E8%A9%A2"
        }
        data = {
            "searchType": "各次考試單科成績",
            "studentNo": student_no,
            "__RequestVerificationToken": token
        }
        
        own_session = False
        if session is None:
            session = self.session_factory()
            own_session = True

        try:
            _log('info', student_no, f"Requesting structure for {student_no}...")
            response = session.post(url, headers=headers, data=data, cookies=cookies)
            response.raise_for_status()
            
            years_data = response.json()
            structure = {}
            
            # Collect items to fetch
            items = []
            for item in years_data:
                name = item.get('DisplayText') or item.get('text')
                value = item.get('Value') or item.get('value')
                if value:
                    items.append((name, value))
            
            # Fetch all exams in parallel
            current_req_id = g.request_id if has_request_context() and 'request_id' in g else None
            
            def _fetch_one(name_value):
                n, v = name_value
                exams = self.get_exams_via_api(cookies, student_no, token, v, req_id=current_req_id, session=session)
                return n, v, exams
            
            with ThreadPoolExecutor(max_workers=min(len(items) or 1, 10)) as pool:
                for name, value, exams in pool.map(_fetch_one, items):
                    structure[name] = {
                        "year_value": value,
                        "exams": exams
                    }
                
            return structure
            
        except Exception as e:
            _log('error', student_no, f"Error fetching structure: {e}")
            return {}
        finally:
            if own_session:
                session.close()

    def get_exams_via_api(self, cookies, student_no, token, year_value, req_id=None, session=None):
        """Helper to fetch exams for a year"""
        url = "https://shcloud2.k12ea.gov.tw/CLHSTYC/ICampus/CommonData/GetGradeCanQueryExamNoListByStudentNo"
        
        year, term = _parse_year_term(year_value, default_year="114", default_term="1")

        headers = {
            "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
             "X-Requested-With": "XMLHttpRequest",
             "Referer": "https://shcloud2.k12ea.gov.tw/CLHSTYC/ICampus/StudentInfo/Index?page=%E6%88%90%E7%B8%BE%E6%9F%A5%E8%A9%A2"
        }
        data = {
            "searchType": "單次考試所有成績",
            "studentNo": student_no,
            "year": year,
            "term": term,
            "__RequestVerificationToken": token
        }
        own_session = False
        if session is None:
            session = self.session_factory()
            own_session = True

        try:
            resp = session.post(url, headers=headers, data=data, cookies=cookies)
            if resp.status_code == 200:
                exams = []
                for item in resp.json():
                     exams.append({
                         "text": item.get('DisplayText') or item.get('text'),
                         "value": item.get('Value') or item.get('value')
                     })
                return exams
        except Exception as e:
            _log('error', student_no, f"Error fetching exams via API: {e}", req_id=req_id)
        finally:
            if own_session:
                session.close()
                
        return []

    def fetch_grades_via_api(self, cookies, student_no, token, year_value, exam_value, session=None):
        """Fetch grades using requests"""
        url = "https://shcloud2.k12ea.gov.tw/CLHSTYC/ICampus/TutorShGrade/GetScoreForStudentExamContent"
        headers = {
            "Accept": "*/*",
            "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            "X-Requested-With": "XMLHttpRequest",
            "Referer": "https://shcloud2.k12ea.gov.tw/CLHSTYC/ICampus/StudentInfo/Index?page=%E6%88%90%E7%B8%BE%E6%9F%A5%E8%A9%A2"
        }
        
        year, term = _parse_year_term(year_value, default_year="114", default_term="2")

        data = {
            "StudentNo": student_no,
            "SearchType": "單次考試所有成績",
            "__RequestVerificationToken": token,
            "Year": year,
            "Term": term,
            "ExamNo": exam_value
        }
        
        _log('info', student_no, f"API Fetching grades: Year={year}, Term={term}, Exam={exam_value}")
        
        own_session = False
        if session is None:
            session = self.session_factory()
            own_session = True

        try:
            response = session.post(url, headers=headers, data=data, cookies=cookies)
            response.raise_for_status()
            return response.json()
        except Exception as e:
            _log('error', student_no, f"API Fetch Error: {e}")
            raise e
        finally:
            if own_session:
                session.close()