"""Team roster parsing and counting helpers."""


def parse_team_members(members_text):
    """Parse the group member text into a list of member dicts.

    Handles multiple historical storage formats:

    1. Current form:  ``Member 1: Name | email | phone | cnic``
    2. Legacy form:   ``Member 2 | Name | Email: x | Phone: y | CNIC: z | Ticket ID: t``
       (labeled fields, any order, with a ``TICKET ID`` / ``LEADER / SOLO`` header line)

    Returns ``[{"name", "email", "phone", "cnic"}]``.  Leader/Solo header rows are
    skipped so they don't become phantom group members.
    """
    parsed = []
    for line in (members_text or "").splitlines():
        clean = line.strip()
        if not clean:
            continue
        # Legacy header rows (leader) must never be treated as a member.
        lower_line = clean.lower()
        if any(k in lower_line for k in ("leader / solo", "leader/solo", "team leader", "solo /", "/ solo", "leader -")):
            continue

        # A leading "Label:" prefix (e.g. "Member 2:") is stripped — but only
        # when the label prefix appears BEFORE the first field separator.
        if ":" in clean and ("|" not in clean or clean.index(":") < clean.index("|")):
            clean = clean.split(":", 1)[1].strip()

        parts = [part.strip() for part in clean.split("|")]

        # Detect labeled fields (legacy format).
        def _labeled(keyword):
            for p in parts:
                if p.lower().startswith(keyword):
                    val = p.split(":", 1)[1].strip() if ":" in p else p
                    return val
            return ""

        labeled_email = _labeled("email")
        labeled_phone = _labeled("phone")
        labeled_cnic = _labeled("cnic")

        if labeled_email or labeled_phone or labeled_cnic:
            # Legacy labeled format: email/phone/cnic come from their labeled
            # fields; the real name is the first part that is neither a
            # "Member N" sequence label nor a labeled field.
            name = ""
            for p in parts:
                low = p.lower().strip()
                if low.startswith(("email", "phone", "cnic", "cnnic", "ticket id", "ticket", "no", "sno", "sr")):
                    continue
                # Skip sequence labels like "Member", "Member 2", "Player 1".
                candidate = low
                for kw in ("member", "player", "participant", "teammate", "team member", "leader"):
                    if candidate.startswith(kw):
                        candidate = candidate[len(kw):].strip(" :.-|")
                        break
                # A leftover that is empty or only digits/symbols is a
                # sequence label (e.g. "2"), not a real name.
                if not candidate or candidate.replace(" ", "").isdigit():
                    continue
                name = p
                break
            # Skip pure "header" fragments that carry no real member data
            if not name and not labeled_email and not labeled_phone:
                continue
            parsed.append({
                "name": name,
                "email": labeled_email,
                "phone": labeled_phone,
                "cnic": labeled_cnic,
            })
        else:
            # Current/positional format: Name | email | phone | cnic
            parsed.append(
                {
                    "name": parts[0] if len(parts) > 0 else "",
                    "email": parts[1] if len(parts) > 1 else "",
                    "phone": parts[2] if len(parts) > 2 else "",
                    "cnic": parts[3] if len(parts) > 3 else "",
                }
            )
    return parsed


def team_member_count(members_text):
    return sum(
        1
        for member in parse_team_members(members_text)
        if member["name"] or member["email"] or member["phone"]
    )


def team_total_count(members_text, entry_type):
    return team_member_count(members_text) + 1 if (entry_type or "").lower() == "group" else 1


def team_roster_text(row):
    if (row["entry_type"] or "").lower() != "group":
        return "Individual player"
    leader_parts = [row['leader_name'] or row['full_name']]
    leader_cnic = row["cnic"] or "" if "cnic" in row.keys() else ""
    if leader_cnic:
        leader_parts.append(leader_cnic)
    roster = ["Team Leader: " + " | ".join(leader_parts)]
    for member in parse_team_members(row["members"]):
        parts = [part for part in (member["name"], member["email"], member["phone"], member.get("cnic", "")) if part]
        if parts:
            roster.append("Member: " + " | ".join(parts))
    return "\n".join(roster)