import random, pyperclip, requests, re
from bs4 import BeautifulSoup
from urllib.parse import quote, urlparse

def _norm(s):
    return s.lower().replace("_", " ").replace("-", " ").replace("–", " ").replace("—", " ").strip()

def extract_tags_danbooru(soup):
    cls = ["character-tag-list", "copyright-tag-list", "artist-tag-list", "general-tag-list"]
    buckets = {c: [] for c in cls}
    for c in cls:
        ul = soup.find("ul", class_=c)
        if ul:
            buckets[c] = [li["data-tag-name"] for li in ul.find_all("li") if li.has_attr("data-tag-name")]
    random.shuffle(buckets["general-tag-list"])
    return buckets["character-tag-list"] + buckets["copyright-tag-list"] + buckets["artist-tag-list"] + buckets["general-tag-list"]

def extract_tags_gelbooru(soup):
    buckets = {"character": [], "copyright": [], "artist": [], "general": []}
    for li in soup.find_all("li", class_=lambda x: x and x.startswith("tag-type-")):
        ttype = li["class"][0].replace("tag-type-", "")
        if ttype in buckets:
            anchors = li.find_all("a")
            if len(anchors) >= 2:
                buckets[ttype].append(anchors[1].text.strip())
    random.shuffle(buckets["general"])
    return buckets["character"] + buckets["copyright"] + buckets["artist"] + buckets["general"]

class ContentGenerator:
    def __init__(self, artist_file="artist.txt", sheet_file="Sheet1.txt"):
        self.artist_lines = self._load(artist_file)
        self.sheet_lines = self._load(sheet_file)

    @staticmethod
    def _load(path):
        with open(path, encoding="utf-8") as f:
            return [ln.strip() for ln in f if ln.strip()]

    def _out(self, text):
        pyperclip.copy(text)
        print(text, "\n\nContent copied to clipboard.")

    def get_random_artists(self):
        res = ", ".join(random.sample(self.artist_lines, random.randint(1, 4)))
        self._out(res)
        return res

    def get_anime_screenshot(self):
        ln = random.choice(self.sheet_lines)
        sp = ln.split(", ")
        idx = 3 if sp[0] in ["1girl", "1boy", "1other"] else 2
        res = f"{', '.join(sp[:idx])}, anime screenshot, {', '.join(sp[idx:])}".rstrip(", ")
        self._out(res)
        return res

    def process_character_lines(self, n, tags=None):
        n = min(n, 5)
        available = self.sheet_lines.copy()
        chosen = []
        if tags:
            normal_tags = [_norm(t) for t in tags if t.strip()]
            for t in normal_tags:
                matches = [ln for ln in available if _norm(ln).find(t) != -1]
                if matches:
                    sel = random.choice(matches)
                    chosen.append(sel)
                    available.remove(sel)
            remaining = n - len(chosen)
            if remaining:
                pool = [ln for t in normal_tags for ln in available if _norm(ln).find(t) != -1]
                if pool:
                    chosen.extend(random.sample(pool, min(remaining, len(pool))))
        missing = n - len(chosen)
        if missing and available:
            chosen.extend(random.sample(available, missing))
        random.shuffle(chosen)
        artists = ", ".join(random.choice(self.artist_lines) for _ in range(random.randint(1, 4)))
        return self._format_characters(chosen, artists)

    def _format_characters(self, lines, artists):
        counts = {"girl": 0, "boy": 0, "other": 0}
        char_entries = []
        src_seen, src_list = set(), []
        for ln in lines:
            sp = [x for x in ln.split(", ") if x != "no humans"]
            if sp[0] in ("1girl", "1boy", "1other"):
                ctype_token = sp[0]
                name, src, tags = sp[1], (sp[2] if len(sp) > 2 else ""), sp[3:]
                if ctype_token == "1girl": counts["girl"] += 1
                elif ctype_token == "1boy": counts["boy"] += 1
                else: counts["other"] += 1
                prefix = ctype_token
            else:
                name, src, tags = sp[0], (sp[1] if len(sp) > 1 else ""), sp[2:]
                counts["other"] += 1
                prefix = None
            tags = [t for t in tags if t not in ("1girl", "1boy", "1other", "female", "male")]
            if src and src not in src_seen:
                src_seen.add(src)
                src_list.append(src)
            entry = ", ".join(([prefix] if prefix else []) + [name] + tags)
            char_entries.append(entry)
        count_part = ", ".join(f"{v}{k}{'s' if v > 1 else ''}" for k, v in counts.items() if v)
        res = f"{count_part}, {', '.join(src_list)}, {artists} | " + " | ".join(char_entries)
        self._out(res)
        return res

    def process_default(self, term=None):
        pool = [l for l in self.sheet_lines if term and term in l] or self.sheet_lines
        ln = random.choice(pool)
        sp = ln.split(", ")
        idx = 3 if sp[0] in ["1girl", "1boy", "1other"] else 2
        artists = ", ".join(random.sample(self.artist_lines, random.randint(1, 4)))
        res = f"{', '.join(sp[:idx])}, {artists}, {', '.join(sp[idx:])}".rstrip(", ")
        self._out(res)
        return res

    def fetch_and_process_tags(self, site, term=None):
        try:
            if site == "d":
                base = "https://danbooru.donmai.us/posts/random"
                url = base + (f"?tags={quote(term.lower().replace(' ', '_'))}" if term else "")
            else:
                url = "https://gelbooru.com/index.php?page=post&s=random"
            r = requests.get(url, allow_redirects=True, timeout=10)
            r.raise_for_status()
            final = r.url
            soup = BeautifulSoup(requests.get(final, timeout=10).text, "html.parser")
            domain = urlparse(final).netloc
            tags = extract_tags_danbooru(soup) if "danbooru" in domain else extract_tags_gelbooru(soup)
            blocked = ["speech bubble","comic","english text","simplified chinese","translated","artist name","side along","subtitles","text","copyright text","black border","furigana","politics","english","translation","russian text","web address"]
            repl = {"v":"peace sign","double v":"double peace","|_|":"bar eyes","\\||/":"open \\m/",":|":"neutral face",";|":"neutral face","eyepatch bikini":"square bikini","tachi-e":"character image"}
            rx = re.compile(r"\d(?:boy|girl|other)s?$", re.I)
            keep = []
            blocked_lc = {b.lower() for b in blocked}
            for t in tags:
                clean = t if len(t) <= 3 else t.replace("_", " ")
                if clean.lower() not in blocked_lc:
                    keep.append(repl.get(clean, clean))
            keep.sort(key=lambda x: not rx.search(x))
            self._out(", ".join(keep))
        except Exception as e:
            self._out(f"Error: {e}")

def main():
    gen = ContentGenerator()
    gen.process_default()
    abbrev = {"1g": "1girl", "1b": "1boy", "1o": "1other", "2g": "2girl", "2b": "2boy", "2o": "2other"}
    while True:
        s = input("\nEnter 'a', 'c', '1-5 [+tags]', 'd [tag]', 'g', or search term: ").strip()
        if not s:
            gen.process_default()
            continue
        s_l = s.lower()
        if s_l == "a":
            gen.get_random_artists()
            continue
        if s_l == "c":
            gen.get_anime_screenshot()
            continue
        if s_l == "g":
            gen.fetch_and_process_tags("g")
            continue
        if s_l.startswith("d "):
            gen.fetch_and_process_tags("d", s[2:].strip())
            continue
        if s_l == "d":
            gen.fetch_and_process_tags("d")
            continue
        m = re.match(r"^(\d+)\s+(.+)$", s)
        if m:
            num = int(m.group(1))
            tags = [t.strip() for t in m.group(2).split(",") if t.strip()]
            gen.process_character_lines(num, tags)
            continue
        if re.fullmatch(r"\d+", s_l):
            gen.process_character_lines(int(s_l))
            continue
        if s_l in abbrev:
            gen.process_default(abbrev[s_l])
            continue
        gen.process_default(s)

if __name__ == "__main__":
    main()