mal/integrations/playback/allanime/extractor.go

package allanime

import (
	"context"
	"fmt"
	"io"
	"mal/pkg/net/limits"
	"net/http"
	"regexp"
	"strconv"
	"strings"
	"time"
)

type providerExtractor struct {
	httpClient *http.Client
	baseURL    string
	referer    string
}

func newProviderExtractor() *providerExtractor {
	return &providerExtractor{
		httpClient: &http.Client{Timeout: 30 * time.Second},
		baseURL:    allAnimeBaseURL,
		referer:    allAnimeReferer,
	}
}

// ExtractVideoLinks fetches provider page and returns stream sources.
func (e *providerExtractor) ExtractVideoLinks(ctx context.Context, providerPath string) ([]StreamSource, error) {
	endpoint := e.baseURL + providerPath

	var resp *http.Response
	var err error

	for attempt := range 3 {
		if attempt > 0 {
			select {
			case <-ctx.Done():
				return nil, ctx.Err()
			case <-time.After(time.Duration(attempt) * 2 * time.Second):
			}
		}

		resp, err = doProxiedRequest(ctx, e.httpClient, endpoint, e.referer)
		if err == nil {
			break
		}

		if attempt == 2 {
			return nil, fmt.Errorf("fetch provider response: %w", err)
		}
	}

	defer func() { _ = resp.Body.Close() }()

	body, err := io.ReadAll(io.LimitReader(resp.Body, limits.MiB2)) // 2MB limit
	if err != nil {
		return nil, fmt.Errorf("read provider response: %w", err)
	}

	return e.parseProviderResponse(ctx, string(body)), nil
}

// parseProviderResponse extracts stream sources from provider JSON response.
func (e *providerExtractor) parseProviderResponse(ctx context.Context, response string) []StreamSource {
	sources := make([]StreamSource, 0)
	providerReferer := e.referer

	// extract per-source referer if present
	refererPattern := regexp.MustCompile(`"Referer":"([^"]+)"`)
	if match := refererPattern.FindStringSubmatch(response); len(match) >= 2 {
		providerReferer = strings.ReplaceAll(match[1], `\/`, "/")
	}
	if providerReferer == "" {
		providerReferer = e.referer
	}

	// extract direct link sources (mp4/embed)
	linkPattern := regexp.MustCompile(`"link":"([^"]+)","resolutionStr":"([^"]+)"`)
	for _, match := range linkPattern.FindAllStringSubmatch(response, -1) {
		if len(match) < 3 {
			continue
		}

		link := strings.ReplaceAll(match[1], `\/`, "/")
		quality := strings.TrimSpace(match[2])
		sourceType := detectStreamType(link)
		if sourceType == "unknown" {
			sourceType = detectEmbedType(link)
		}

		sources = append(sources, StreamSource{
			URL:      link,
			Quality:  quality,
			Provider: "wixmp",
			Type:     sourceType,
			Referer:  providerReferer,
		})
	}

	// extract HLS playlist sources
	hlsPattern := regexp.MustCompile(`"url":"([^"]+)","hardsub_lang":"en-US"`)
	for _, match := range hlsPattern.FindAllStringSubmatch(response, -1) {
		if len(match) < 2 {
			continue
		}

		playlistURL := strings.ReplaceAll(match[1], `\/`, "/")
		if strings.Contains(playlistURL, "master.m3u8") {
			parsed, err := e.parseM3U8(ctx, playlistURL, providerReferer)
			if err == nil {
				sources = append(sources, parsed...)
			}
			continue
		}

		sources = append(sources, StreamSource{
			URL:      playlistURL,
			Quality:  "auto",
			Provider: "hls",
			Type:     "m3u8",
			Referer:  providerReferer,
		})
	}

	// extract subtitles and attach to all sources
	subtitlePattern := regexp.MustCompile(`"subtitles":\[(.*?)\]`)
	if subtitleMatch := subtitlePattern.FindStringSubmatch(response); len(subtitleMatch) >= 2 {
		subtitles := make([]Subtitle, 0)
		subtitleEntryPattern := regexp.MustCompile(`"lang":"([^"]+)".*?"src":"([^"]+)"`)
		for _, entry := range subtitleEntryPattern.FindAllStringSubmatch(subtitleMatch[1], -1) {
			if len(entry) < 3 {
				continue
			}

			subtitles = append(subtitles, Subtitle{
				Lang: strings.TrimSpace(entry[1]),
				URL:  strings.ReplaceAll(entry[2], `\/`, "/"),
			})
		}

		if len(subtitles) > 0 {
			for idx := range sources {
				sources[idx].Subtitles = subtitles
			}
		}
	}

	return sources
}

// parseM3U8 fetches a master playlist and extracts individual stream URLs with bandwidth-derived quality.
func (e *providerExtractor) parseM3U8(ctx context.Context, masterURL string, referer string) ([]StreamSource, error) {
	resp, err := doProxiedRequest(ctx, e.httpClient, masterURL, referer)
	if err != nil {
		return nil, err
	}
	defer func() { _ = resp.Body.Close() }()

	body, err := io.ReadAll(io.LimitReader(resp.Body, limits.KiB512)) // 512KB limit
	if err != nil {
		return nil, err
	}

	lines := strings.Split(string(body), "\n")
	baseURL := masterURL
	if idx := strings.LastIndex(masterURL, "/"); idx >= 0 {
		baseURL = masterURL[:idx+1]
	}

	currentBandwidth := 0
	sources := make([]StreamSource, 0)
	bwPattern := regexp.MustCompile(`BANDWIDTH=(\d+)`)

	for _, line := range lines {
		trimmed := strings.TrimSpace(line)
		if strings.HasPrefix(trimmed, "#EXT-X-STREAM-INF") {
			match := bwPattern.FindStringSubmatch(trimmed)
			if len(match) >= 2 {
				value, convErr := strconv.Atoi(match[1])
				if convErr == nil {
					currentBandwidth = value
				}
			}
			continue
		}

		// skip empty lines and non-stream lines
		if trimmed == "" || strings.HasPrefix(trimmed, "#") {
			continue
		}

		streamURL := trimmed
		if !strings.HasPrefix(streamURL, "http://") && !strings.HasPrefix(streamURL, "https://") {
			streamURL = baseURL + streamURL
		}

		quality := "auto"
		kbps := currentBandwidth / 1000
		switch {
		case kbps >= 8000:
			quality = "1080p"
		case kbps >= 5000:
			quality = "720p"
		case kbps >= 2500:
			quality = "480p"
		case kbps > 0:
			quality = "360p"
		}

		sources = append(sources, StreamSource{
			URL:      streamURL,
			Quality:  quality,
			Provider: "hls",
			Type:     "m3u8",
			Referer:  referer,
		})
	}

	return sources, nil
}