async function searchResults(query) {
  const encodeQuery = keyword => encodeURIComponent(keyword);
  const searchBaseUrl = "https://1movies.bz/browser?keyword=";
  const baseUrl = "https://1movies.bz";
  
  const posterHrefRegex = /href="([^"]*)" class="poster"/g;
  const titleRegex = /class="title" href="[^"]*">([^<]*)</g;
  const imageRegex = /data-src="([^"]*)"/g;
  
  const extractResultsFromHTML = (htmlText) => {
    const results = [];
    const posterMatches = [...htmlText.matchAll(posterHrefRegex)];
    const titleMatches = [...htmlText.matchAll(titleRegex)];
    const imageMatches = [...htmlText.matchAll(imageRegex)];
    
    const minLength = Math.min(posterMatches.length, titleMatches.length, imageMatches.length);
    
    for (let index = 0; index < minLength; index++) {
      const href = posterMatches[index][1];
      const fullHref = href.startsWith("http") ? href : baseUrl + href;
      
      const imageSrc = imageMatches[index][1];
      
      const title = titleMatches[index][1];
      const cleanTitle = decodeHtmlEntities(title);
      
      if (fullHref && imageSrc && cleanTitle) {
        results.push({
          href: fullHref,
          image: "https://deno-proxies-sznvnpnxwhbv.deno.dev/?url=" + encodeURIComponent(imageSrc),
          title: cleanTitle
        });
      }
    }
    return results;
  };
  
  try {
    const encodedQuery = encodeQuery(query);
    
    const urls = [
      `${searchBaseUrl}${encodedQuery}`,
      `${searchBaseUrl}${encodedQuery}&page=2`,
      `${searchBaseUrl}${encodedQuery}&page=3`
    ];
    
    const responses = await Promise.all(urls.map(url => fetchv2("https://deno-proxies-sznvnpnxwhbv.deno.dev/?url=" + encodeURIComponent(url))));
    
    const htmlTexts = await Promise.all(responses.map(response => response.text()));
    
    const allResults = [];
    htmlTexts.forEach(htmlText => {
      const pageResults = extractResultsFromHTML(htmlText);
      allResults.push(...pageResults);
    });
    
    return JSON.stringify(allResults);
  } catch (error) {
    return JSON.stringify([{
      href: "",
      image: "",
      title: "Search failed: " + error.message
      }]);
    }
  }

async function extractDetails(url) {
  try {
    const response = await fetchv2(url);
    const htmlText = await response.text();

    const descriptionMatch = (/<div class="description text-expand">([\s\S]*?)<\/div>/.exec(htmlText) || [])[1];
    const aliasesMatch = (/<small class="al-title text-expand">([\s\S]*?)<\/small>/.exec(htmlText) || [])[1];
    const airdateMatch = (/<li>Released:\s*<span[^>]*>(.*?)<\/span>/.exec(htmlText) || [])[1];

    return JSON.stringify([{
      description: descriptionMatch ? cleanHtmlSymbols(descriptionMatch) : "Not available",
      aliases: aliasesMatch ? cleanHtmlSymbols(aliasesMatch) : "Not aliases",
      airdate: airdateMatch ? cleanHtmlSymbols(airdateMatch) : "Not available"
    }]);
  } catch (error) {
    console.error("Error fetching details:" + error);
    return [{
      description: "Error loading description",
      aliases: "Not available",
      airdate: "Not available"
    }];
  }
}

async function extractEpisodes(movieUrl) {
    try {
        const response = await fetchv2(movieUrl);
        const htmlText = await response.text();
        const movieIDMatch = (htmlText.match(/<div class="detail-lower"[^>]*id="movie-rating"[^>]*data-id="([^"]+)"/) || [])[1];
        if (!movieIDMatch) {
            return [{
                error: "MovieID not found"
            }];
        }
        
        const movieIdApiUrl = `https://enc-dec.app/api/enc-movies-flix?text=${movieIDMatch}`;
        const movieIdTokenResponse = await fetchv2(movieIdApiUrl);
        const movieIdTokenData = await movieIdTokenResponse.json();
        const token = movieIdTokenData.result;
        
        const episodeListUrl = `https://1movies.bz/ajax/episodes/list?id=${movieIDMatch}&_=${token}`;
        const episodeListResponse = await fetchv2(episodeListUrl);
        const episodeListData = await episodeListResponse.json();
        const cleanedHtml = cleanJsonHtml(episodeListData.result);
        
        const episodeRegex = /<a[^>]+eid="([^"]+)"[^>]+num="([^"]+)"[^>]*>/g;
        const episodeMatches = [...cleanedHtml.matchAll(episodeRegex)];
        
        const episodes = episodeMatches.map(([_, episodeToken, episodeNum]) => ({
            number: parseInt(episodeNum, 10), 
            href: `https://1movies.bz/ajax/links/list?eid=${episodeToken}&_=ENCRYPT_ME` 
        }));
        
        return JSON.stringify(episodes);
    } catch (err) {
        console.error("Error fetching episodes:" + err);
        return [{
            number: 1,
            href: "Error fetching episodes"
        }];
    }
}

async function extractStreamUrl(url) {
  const headers = {
    "Referer": "https://1movies.bz/",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36"
  };

  try {
    const eidMatch = url.match(/eid=([^&]+)/);
    if (eidMatch && eidMatch[1]) {
      const rawEpisodeToken = eidMatch[1];
      const encryptResponse = await fetchv2(`https://enc-dec.app/api/enc-movies-flix?text=${rawEpisodeToken}`);
      const encryptData = await encryptResponse.json();
      const encryptedToken = encryptData.result;
      url = url.replace('&_=ENCRYPT_ME', `&_=${encryptedToken}`);
    }
    
    const response = await fetchv2(url);
    const responseData = await response.json();
    const cleanedHtml = cleanJsonHtml(responseData.result);
    
    const spanRegex = /<div class="server wnav-item"[^>]*data-lid="([^"]+)"[^>]*>/g;
    const ids = [];
    let match;
    while ((match = spanRegex.exec(cleanedHtml)) !== null) ids.push(match[1]);
    
    if (ids.length === 0) {
      console.log("No servers found");
      return "error";
    }
    
    const serverId = ids.length > 1 ? ids[1] : ids[0];
    
    const tokenData = await fetchv2(`https://enc-dec.app/api/enc-movies-flix?text=${encodeURIComponent(serverId)}`)
      .then(res => res.json());
    const token = tokenData.result;
    
    if (!token) {
      console.log("Token not found");
      return "error";
    }
    
    const streamUrl = `https://1movies.bz/ajax/links/view?id=${serverId}&_=${token}`;
    const streamResponse = await fetchv2(streamUrl);
    const streamData = await streamResponse.json();
    
    if (!streamData.result) {
      console.log("Stream result not found");
      return "error";
    }

    const decryptData = await fetchv2(
      `https://enc-dec.app/api/dec-movies-flix?text=${streamData.result}`,
      headers
    ).then(res => res.json());

    const decryptedUrl = decryptData.result?.url;

    if (!decryptedUrl) {
      console.log("Decryption failed");
      return "error";
    }

    const subListEncoded = decryptedUrl.split("sub.list=")[1]?.split("&")[0];
    let subtitles = "N/A";
    if (subListEncoded) {
      try {
        const subListUrl = decodeURIComponent(subListEncoded);
        const subResponse = await fetchv2(subListUrl);
        subtitles = await subResponse.json();
      } catch {
        subtitles = "N/A";
      }
    }

    const englishSubUrl = Array.isArray(subtitles)
      ? subtitles.find(sub => sub.label === "English")?.file.replace(/\\\//g, "/")
      : "N/A";
    
    let finalUrl = decryptedUrl;
    if (finalUrl.includes(".to/iframe")) {
      try {
        const iframeResponse = await fetchv2(finalUrl, headers);
        const iframeHtml = await iframeResponse.text();
        const iframeSrcMatch = iframeHtml.match(/<iframe[^>]+src="([^"]+)"/i);
        if (iframeSrcMatch && iframeSrcMatch[1]) {
          finalUrl = iframeSrcMatch[1];
        } else {
          console.log("No iframe src found in:", finalUrl);
          return "error";
        }
      } catch (e) {
        console.log("Error fetching iframe:", e);
        return "error";
      }
    }
    
    const mediaResponse = await fetchv2(finalUrl.replace("/e/", "/media/"), headers);
    const mediaJson = await mediaResponse.json();
    
    const result = mediaJson?.result;
    if (!result) {
      console.log("Media result not found");
      return "error";
    }
    
    const finalJson = await fetchv2(
      "https://enc-dec.app/api/dec-mega",
      { "Content-Type": "application/json" },
      "POST",
      JSON.stringify({ text: result, agent: headers["User-Agent"] })
    ).then(res => res.json());
    console.log("Final JSON: " + JSON.stringify(finalJson));
    const m3u8Link = finalJson?.result?.sources?.[0]?.file;

    const streams = [];
    if (m3u8Link) {
      let pushedQualities = 0;
      try {
        const m3u8Response = await fetchv2("https://1anime.app/api/m3u8-proxy?url=" + encodeURIComponent(m3u8Link));
        const m3u8Text = await m3u8Response.text();
        const lines = m3u8Text.split('\n');
        
        for (let i = 0; i < lines.length; i++) {
          const line = lines[i].trim();
          if (line.startsWith('#EXT-X-STREAM-INF:')) {
            const resolutionMatch = line.match(/RESOLUTION=(\d+x\d+)/);
            let quality = 'Unknown';
            
            if (resolutionMatch) {
              const [width, height] = resolutionMatch[1].split('x');
              quality = `${height}p`;
            }
            
            if (i + 1 < lines.length) {
              let streamPath = lines[i + 1].trim();
              let absolutePath;
              if (streamPath.startsWith('/api/')) {
                absolutePath = 'https://1anime.app' + streamPath;
              } else if (streamPath.startsWith('http')) {
                absolutePath = "https://1anime.app/api/m3u8-proxy?url=" + encodeURIComponent(streamPath);
              } else {
                const baseUrl = m3u8Link.substring(0, m3u8Link.lastIndexOf('/') + 1);
                absolutePath = "https://1anime.app/api/m3u8-proxy?url=" + encodeURIComponent(baseUrl + streamPath);
              }
              streams.push({
                title: quality,
                streamUrl: absolutePath
              });
              pushedQualities++;
            }
          }
        }
      } catch (e) {
        console.log("Failed to extract qualities:", e);
      }
      
      if (pushedQualities === 0) {
        streams.push({
          title: "Source",
          streamUrl: "https://1anime.app/api/m3u8-proxy?url=" + encodeURIComponent(m3u8Link)
        });
      }
    }
    const returnValue = {
      streams: streams,
      subtitles: englishSubUrl !== "N/A" ? englishSubUrl : ""
    };
    console.log("RETURN: " + JSON.stringify(returnValue));
    return JSON.stringify(returnValue);

  } catch (error) {
    console.log("Fetch error:" + error);
    return "https://error.org";
  }
}

function cleanHtmlSymbols(string) {
  if (!string) {
    return "";
  }
  return string
    .replace(/&#8217;/g, "'")
    .replace(/&#8211;/g, "-")
    .replace(/&#[0-9]+;/g, "")
    .replace(/\r?\n|\r/g, " ")
    .replace(/\s+/g, " ")
    .trim();
}

function cleanJsonHtml(jsonHtml) {
  if (!jsonHtml) {
    return "";
  }
  return jsonHtml
    .replace(/\\"/g, "\"")
    .replace(/\\'/g, "'")
    .replace(/\\\\/g, "\\")
    .replace(/\\n/g, "\n")
    .replace(/\\t/g, "\t")
    .replace(/\\r/g, "\r");
}

function decodeHtmlEntities(text) {
  if (!text) {
    return "";
  }
  return text
    .replace(/&#039;/g, "'")
    .replace(/&quot;/g, "\"")
    .replace(/&amp;/g, "&")
    .replace(/&lt;/g, "<")
    .replace(/&gt;/g, ">")
    .replace(/&nbsp;/g, " ");
}