import os
import io
import json
import urllib.parse
import requests
from fastapi import FastAPI, File, UploadFile, Form, Request, BackgroundTasks
from fastapi.responses import HTMLResponse
from PIL import Image
import imagehash
from playwright.sync_api import sync_playwright

app = FastAPI()

DATABASE_DIR = "scam_database"
VOTES_FILE = "votes.json"

# ฟังก์ชันโหลดข้อมูลโหวตจากไฟล์ JSON
def load_votes():
    if os.path.exists(VOTES_FILE):
        try:
            with open(VOTES_FILE, "r", encoding="utf-8") as f:
                return json.load(f)
        except Exception:
            return {}
    return {}

# ฟังก์ชันบันทึกข้อมูลโหวตลงไฟล์ JSON
def save_votes(votes_data):
    with open(VOTES_FILE, "w", encoding="utf-8") as f:
        json.dump(votes_data, f, ensure_ascii=False, indent=2)

# ฟังก์ชันดึง Hash ของรูปทั้งหมดในฐานข้อมูล
def get_database_hashes():
    hashes = {}
    if not os.path.exists(DATABASE_DIR):
        os.makedirs(DATABASE_DIR)
        
    for filename in os.listdir(DATABASE_DIR):
        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
            filepath = os.path.join(DATABASE_DIR, filename)
            try:
                img = Image.open(filepath)
                h = str(imagehash.phash(img))
                hashes[filename] = h
            except Exception as e:
                print(f"Error loading {filename}: {e}")
    return hashes

# ฟังก์ชันดึง IP ของผู้ใช้
def get_client_ip(request: Request):
    forwarded_for = request.headers.get("x-forwarded-for")
    if forwarded_for:
        return forwarded_for.split(",")[0].strip()
    return request.client.host if request.client else "127.0.0.1"

# ---------------------------------------------------------
# ระบบบอทสแกนรูปภาพจาก TikTok (เพิ่มระบบกันตรวจจับบอท)
# ---------------------------------------------------------
def run_tiktok_bot_task(keyword: str):
    db_hashes = get_database_hashes()
    existing_hash_objs = [imagehash.hex_to_hash(h) for h in db_hashes.values()]
    MATCH_THRESHOLD = 12

    encoded_keyword = urllib.parse.quote(keyword)
    search_url = f"https://www.tiktok.com/search?q={encoded_keyword}"

    try:
        with sync_playwright() as p:
            # เพิ่ม args ปลอมตัวไม่ให้ TikTok บล็อกบอท
            browser = p.chromium.launch(
                headless=True,
                args=[
                    "--no-sandbox",
                    "--disable-setuid-sandbox",
                    "--disable-blink-features=AutomationControlled",
                    "--disable-dev-shm-usage"
                ]
            )
            context = browser.new_context(
                user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
                viewport={"width": 1280, "height": 800},
                locale="th-TH"
            )

            page = context.new_page()
            # ซ่อนสถานะ webdriver
            page.add_init_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")

            print(f"[Bot] กำลังเปิด TikTok ค้นหาคำว่า: '{keyword}'")
            page.goto(search_url, wait_until="domcontentloaded", timeout=45000)
            page.wait_for_timeout(5000)

            # เลื่อนหน้าจอลงหลายๆ ครั้งกระตุ้นให้คลิปโหลด
            for _ in range(4):
                page.mouse.wheel(0, 1000)
                page.wait_for_timeout(2000)

            # ค้นหาลิงก์คลิปทั้งหมดในหน้าค้นหา
            video_links = set()
            links = page.query_selector_all("a")
            for a in links:
                href = a.get_attribute("href")
                if href and ("/video/" in href or "/photo/" in href):
                    if href.startswith("/"):
                        href = "https://www.tiktok.com" + href
                    clean_url = href.split("?")[0]
                    video_links.add(clean_url)

            video_list = list(video_links)
            print(f"[Bot] เจอวิดีโอจากหน้าค้นหาทั้งหมด {len(video_list)} คลิป")

            # สแกนทีละคลิป (สูงสุด 5 คลิปแรก)
            for v_idx, v_url in enumerate(video_list[:5]):
                try:
                    print(f"[Bot] ({v_idx+1}/{min(len(video_list), 5)}) กำลังเข้าไปสแกนคอมเมนต์คลิป: {v_url}")
                    page.goto(v_url, wait_until="domcontentloaded", timeout=30000)
                    page.wait_for_timeout(4000)

                    # สกรอลล์ลงไปส่วนคอมเมนต์
                    page.mouse.wheel(0, 1000)
                    page.wait_for_timeout(2500)

                    # ดึงเฉพาะรูปภาพที่แนบมาในคอมเมนต์
                    comment_imgs = page.query_selector_all(
                        "[data-e2e='comment-list'] img, [class*='comment'] img, div[class*='Comment'] img"
                    )

                    print(f"[Bot] พบรูปในคอมเมนต์จำนวน {len(comment_imgs)} รูป")

                    for img_el in comment_imgs:
                        src = img_el.get_attribute("src")
                        if not src or not src.startswith("http"):
                            continue

                        try:
                            resp = requests.get(src, timeout=5)
                            if resp.status_code == 200:
                                img = Image.open(io.BytesIO(resp.content))

                                # กรองรูปโปรไฟล์ขนาดเล็กออก (รูปในคอมเมนต์มักจะใหญ่กว่า 120px)
                                if img.width < 120 or img.height < 120:
                                    continue

                                new_hash_obj = imagehash.phash(img)

                                is_dup = False
                                for existing_h in existing_hash_objs:
                                    if (new_hash_obj - existing_h) <= MATCH_THRESHOLD:
                                        is_dup = True
                                        break

                                if not is_dup:
                                    filename = f"bot_{str(new_hash_obj)}.jpg"
                                    filepath = os.path.join(DATABASE_DIR, filename)
                                    img.convert("RGB").save(filepath, "JPEG")
                                    existing_hash_objs.append(new_hash_obj)
                                    print(f"[Bot] ✅ บันทึกรูปใหม่จากคอมเมนต์: {filename}")
                                else:
                                    print(f"[Bot] ❌ รูปในคอมเมนต์ซ้ำแล้ว - ข้าม")
                        except Exception:
                            continue
                except Exception as ve:
                    print(f"[Bot Error] เข้าดูคลิปไม่ได้: {ve}")
                    continue

            browser.close()
            print(f"[Bot] สแกนเสร็จสิ้นสำหรับคำว่า '{keyword}'")
    except Exception as e:
        print(f"[Bot Error] {e}")

# Endpoint สำหรับสั่งให้บอทเริ่มทำงาน
@app.post("/bot/run")
async def trigger_bot(
    keyword: str = Form(...), 
    background_tasks: BackgroundTasks = BackgroundTasks()
):
    background_tasks.add_task(run_tiktok_bot_task, keyword)
    return {
        "success": True, 
        "message": f"บอทเริ่มค้นหาคำว่า '{keyword}' และสแกนรูปในคอมเมนต์เรียบร้อยแล้ว"
    }

# ---------------------------------------------------------
# Endpoint เดิม (100% ตามโค้ดเดิม)
# ---------------------------------------------------------
@app.get("/", response_class=HTMLResponse)
def serve_index():
    if os.path.exists("index.html"):
        with open("index.html", "r", encoding="utf-8") as f:
            return f.read()
    return "<h1>index.html not found</h1>"

@app.post("/check")
async def check_image(file: UploadFile = File(...)):
    try:
        contents = await file.read()
        uploaded_img = Image.open(io.BytesIO(contents))
        uploaded_hash_obj = imagehash.phash(uploaded_img)
        uploaded_hash_str = str(uploaded_hash_obj)

        db_hashes = get_database_hashes()
        votes_data = load_votes()

        MATCH_THRESHOLD = 12
        matched_hash_key = None
        is_in_db = False

        for filename, db_hash_str in db_hashes.items():
            db_hash_obj = imagehash.hex_to_hash(db_hash_str)
            distance = uploaded_hash_obj - db_hash_obj
            if distance <= MATCH_THRESHOLD:
                matched_hash_key = db_hash_str
                is_in_db = True
                break

        if not matched_hash_key:
            matched_hash_key = uploaded_hash_str

        image_vote = votes_data.get(matched_hash_key, {"likes": 0, "dislikes": 0, "users": {}})
        likes = image_vote.get("likes", 0)
        dislikes = image_vote.get("dislikes", 0)

        if likes >= 100:
            is_scam = False
            result_text = "ปลอดภัย"
            detail_text = f"รูปภาพนี้ได้รับการยืนยันว่าปลอดภัยจากผู้ใช้งาน (กดไลก์ {likes} คน)"
        elif is_in_db:
            is_scam = True
            result_text = "มิจแน่นอน100%"
            detail_text = "พบรูปภาพตรงกับฐานข้อมูลรูปภาพโปรโมทหลอกลวง"
        else:
            is_scam = False
            result_text = "ไม่สามารถตรวจสอบได้"
            detail_text = "ยังไม่พบรูปภาพนี้ในฐานข้อมูลมิจฉาชีพ"

        return {
            "is_scam": is_scam,
            "result": result_text,
            "detail": detail_text,
            "image_hash": matched_hash_key,
            "likes": likes,
            "dislikes": dislikes
        }
    except Exception as e:
        return {"error": f"เกิดข้อผิดพลาดในการประมวลผล: {str(e)}"}

@app.post("/vote")
async def vote_image(
    request: Request,
    image_hash: str = Form(...),
    vote_type: str = Form(...),
    user_id: str = Form(None)
):
    try:
        votes_data = load_votes()
        if image_hash not in votes_data:
            votes_data[image_hash] = {"likes": 0, "dislikes": 0, "users": {}}
        elif "users" not in votes_data[image_hash]:
            votes_data[image_hash]["users"] = {}

        client_ip = get_client_ip(request)
        user_key = f"{client_ip}_{user_id}" if user_id else client_ip

        if user_key in votes_data[image_hash]["users"]:
            return {
                "success": False,
                "error": "คุณเคยโหวตรูปภาพนี้ไปแล้ว สามารถโหวตได้เพียง 1 ครั้งเท่านั้น"
            }

        votes_data[image_hash]["users"][user_key] = vote_type

        if vote_type == "like":
            votes_data[image_hash]["likes"] += 1
        elif vote_type == "dislike":
            votes_data[image_hash]["dislikes"] += 1

        save_votes(votes_data)

        likes = votes_data[image_hash]["likes"]
        dislikes = votes_data[image_hash]["dislikes"]

        db_hashes = get_database_hashes()
        is_in_db = image_hash in db_hashes.values()

        if likes >= 100:
            is_scam = False
            result_text = "ปลอดภัย"
            detail_text = f"รูปภาพนี้ได้รับการยืนยันว่าปลอดภัยจากผู้ใช้งาน (กดไลก์ {likes} คน)"
        elif is_in_db:
            is_scam = True
            result_text = "มิจแน่นอน100%"
            detail_text = "พบรูปภาพตรงกับฐานข้อมูลรูปภาพโปรโมทหลอกลวง"
        else:
            is_scam = False
            result_text = "ไม่สามารถตรวจสอบได้"
            detail_text = "ยังไม่พบรูปภาพนี้ในฐานข้อมูลมิจฉาชีพ"

        return {
            "success": True,
            "likes": likes,
            "dislikes": dislikes,
            "is_scam": is_scam,
            "result": result_text,
            "detail": detail_text
        }
    except Exception as e:
        return {"error": f"เกิดข้อผิดพลาดในการโหวต: {str(e)}"}