from threading import Thread, Lock
from queue import Queue
from urllib.parse import urlparse

class Solution:
    def crawl(self, startUrl: str, htmlParser: 'HtmlParser') -> List[str]:
        hostname = urlparse(startUrl).hostname
        visited = set()
        visited_lock = Lock()
        q = Queue()
        q.put(startUrl)
        visited.add(startUrl)

        def worker():
            while True:
                try:
                    url = q.get(timeout=0.1)
                except:
                    return
                for next_url in htmlParser.getUrls(url):
                    if urlparse(next_url).hostname == hostname:
                        with visited_lock:
                            if next_url not in visited:
                                visited.add(next_url)
                                q.put(next_url)
                q.task_done()

        threads = []
        for _ in range(8):  # You can adjust thread count
            t = Thread(target=worker)
            t.daemon = True
            t.start()
            threads.append(t)
        q.join()
        return list(visited)
      

#include <vector>
#include <string>
#include <unordered_set>
#include <queue>
#include <mutex>
#include <thread>
#include <regex>

using namespace std;

// This is the HtmlParser's API interface.
// You should not implement it, or speculate about its implementation
class HtmlParser {
public:
    vector<string> getUrls(string url);
};

class Solution {
public:
    string getHostname(const string& url) {
        // Simple parse: "http://hostname/..."
        size_t start = url.find("://");
        if (start == string::npos) return "";
        start += 3;
        size_t end = url.find('/', start);
        if (end == string::npos) return url.substr(start);
        return url.substr(start, end - start);
    }

    vector<string> crawl(string startUrl, HtmlParser htmlParser) {
        string hostname = getHostname(startUrl);
        unordered_set<string> visited;
        mutex visited_mutex;
        queue<string> q;
        q.push(startUrl);
        visited.insert(startUrl);

        auto worker = [&]() {
            while (true) {
                string url;
                {
                    lock_guard<mutex> lock(visited_mutex);
                    if (q.empty()) return;
                    url = q.front();
                    q.pop();
                }
                vector<string> urls = htmlParser.getUrls(url);
                for (const string& next_url : urls) {
                    if (getHostname(next_url) == hostname) {
                        lock_guard<mutex> lock(visited_mutex);
                        if (visited.count(next_url) == 0) {
                            visited.insert(next_url);
                            q.push(next_url);
                        }
                    }
                }
            }
        };

        vector<thread> threads;
        for (int i = 0; i < 8; ++i)
            threads.emplace_back(worker);
        for (auto& t : threads)
            t.join();

        vector<string> res(visited.begin(), visited.end());
        return res;
    }
};
      

import java.util.*;
import java.util.concurrent.*;
import java.net.*;

class HtmlParser {
    public List<String> getUrls(String url) { return new ArrayList<>(); }
}

class Solution {
    public List<String> crawl(String startUrl, HtmlParser htmlParser) {
        String hostname = getHostname(startUrl);
        Set<String> visited = ConcurrentHashMap.newKeySet();
        visited.add(startUrl);
        Queue<String> queue = new ConcurrentLinkedQueue<>();
        queue.add(startUrl);

        ExecutorService pool = Executors.newFixedThreadPool(8);
        List<Future<?>> futures = new ArrayList<>();

        Runnable worker = () -> {
            while (true) {
                String url = queue.poll();
                if (url == null) break;
                for (String nextUrl : htmlParser.getUrls(url)) {
                    if (getHostname(nextUrl).equals(hostname) && visited.add(nextUrl)) {
                        queue.add(nextUrl);
                    }
                }
            }
        };

        for (int i = 0; i < 8; ++i)
            futures.add(pool.submit(worker));
        for (Future<?> f : futures) {
            try { f.get(); } catch (Exception e) {}
        }
        pool.shutdown();

        return new ArrayList<>(visited);
    }

    private String getHostname(String url) {
        try {
            URL u = new URL(url);
            return u.getHost();
        } catch (Exception e) {
            return "";
        }
    }
}
      

/**
 * // This is the HtmlParser's API interface.
 * // function HtmlParser() {
 * //    @param {string} url
 * //    @return {string[]}
 * //    this.getUrls = function(url) {
 * //      ...
 * //    };
 * // }
 */
/**
 * @param {string} startUrl
 * @param {HtmlParser} htmlParser
 * @return {string[]}
 */
var crawl = function(startUrl, htmlParser) {
    function getHostname(url) {
        return url.split('/')[2];
    }
    const hostname = getHostname(startUrl);
    const visited = new Set();
    visited.add(startUrl);
    const queue = [startUrl];

    // JavaScript is single-threaded in LeetCode, but we can simulate concurrency with async/await
    let idx = 0;
    async function bfs() {
        while (idx < queue.length) {
            const url = queue[idx++];
            const urls = htmlParser.getUrls(url);
            for (const nextUrl of urls) {
                if (getHostname(nextUrl) === hostname && !visited.has(nextUrl)) {
                    visited.add(nextUrl);
                    queue.push(nextUrl);
                }
            }
        }
    }
    // In practice, LeetCode will not run this in parallel, but we can still use async
    return Array.from(visited);
};