parser.go

package main

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"log/slog"
	"net/http"
	"regexp"
	"strconv"
	"strings"
	"time"

	"github.com/andrianbdn/iospng"
	"github.com/klauspost/compress/zip"
	"howett.net/plist"
)

const (
	MaxRetries = 3
	RetryDelay = 1000 * time.Millisecond
)

var infoPlistRegex = regexp.MustCompile(`^Payload/[^/]+\.app/Info\.plist$`)

// HttpReaderAt implements io.ReaderAt using HTTP Range requests
type HttpReaderAt struct {
	ctx    context.Context
	client *http.Client
	url    string
}

func (r *HttpReaderAt) ReadAt(p []byte, off int64) (int, error) {
	if len(p) == 0 {
		return 0, nil
	}

	rangeHeader := fmt.Sprintf("bytes=%d-%d", off, off+int64(len(p))-1)
	var lastErr error

	for attempt := 0; attempt <= MaxRetries; attempt++ {
		if attempt > 0 {
			// Exponential backoff: 1s, 2s, 3s...
			time.Sleep(RetryDelay * time.Duration(attempt))
			slog.Debug("Retrying range request", "url", r.url, "range", rangeHeader, "attempt", attempt)
		}

		req, err := http.NewRequestWithContext(r.ctx, "GET", r.url, nil)
		if err != nil {
			return 0, err
		}

		req.Header.Set("Range", rangeHeader)
		req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")

		resp, err := r.client.Do(req)
		if err != nil {
			lastErr = fmt.Errorf("HTTP request failed: %w", err)
			continue
		}

		if resp.StatusCode != http.StatusPartialContent {
			if resp.StatusCode == http.StatusOK && off > 0 {
				resp.Body.Close()
				return 0, fmt.Errorf("server does not support range requests (status 200 for offset %d)", off)
			}
			if resp.StatusCode >= 500 {
				lastErr = fmt.Errorf("server error %d for range %s", resp.StatusCode, rangeHeader)
				resp.Body.Close()
				continue
			}
			if resp.StatusCode != http.StatusOK {
				resp.Body.Close()
				return 0, fmt.Errorf("unexpected status code %d for range %s", resp.StatusCode, rangeHeader)
			}
		}

		n, err := io.ReadFull(resp.Body, p)
		resp.Body.Close()
		if err != nil && err != io.ErrUnexpectedEOF {
			lastErr = fmt.Errorf("failed to read body: %w", err)
			continue
		}
		return n, err
	}

	return 0, lastErr
}


// OpenRemoteZip opens a remote ZIP file using HTTP Range requests and returns a zip.Reader and its total size
func OpenRemoteZip(ctx context.Context, url string, client *http.Client, knownSize int64) (*zip.Reader, int64, error) {
	var actualSize int64 = knownSize

	if actualSize <= 0 {
		var resp *http.Response
		var err error

		// Initial request to get size and check availability
		for attempt := 1; attempt <= MaxRetries+1; attempt++ {
			req, _ := http.NewRequestWithContext(ctx, "HEAD", url, nil)
			req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
			
			resp, err = client.Do(req)
			if err == nil && resp.StatusCode == http.StatusOK {
				break
			}
			
			// Fallback to GET if HEAD is not supported or fails
			req, _ = http.NewRequestWithContext(ctx, "GET", url, nil)
			req.Header.Set("Range", "bytes=0-0")
			req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
			resp, err = client.Do(req)
			if err == nil && (resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusPartialContent) {
				break
			}

			if attempt <= MaxRetries {
				if resp != nil {
					resp.Body.Close()
				}
				time.Sleep(RetryDelay * time.Duration(attempt))
				continue
			}
			return nil, 0, fmt.Errorf("failed to reach URL after %d attempts: %v", MaxRetries+1, err)
		}
		defer resp.Body.Close()

		if resp.StatusCode == http.StatusPartialContent {
			cr := resp.Header.Get("Content-Range")
			if cr != "" {
				parts := regexp.MustCompile(`/(\d+)$`).FindStringSubmatch(cr)
				if len(parts) > 1 {
					actualSize, _ = strconv.ParseInt(parts[1], 10, 64)
				}
			}
		} else {
			contentLength := resp.Header.Get("Content-Length")
			actualSize, _ = strconv.ParseInt(contentLength, 10, 64)
		}
	}

	if actualSize <= 0 {
		return nil, 0, fmt.Errorf("could not determine file size")
	}

	readerAt := &HttpReaderAt{
		ctx:    ctx,
		client: client,
		url:    url,
	}

	zr, err := zip.NewReader(readerAt, actualSize)
	if err != nil {
		return nil, 0, fmt.Errorf("failed to read zip header: %w", err)
	}

	return zr, actualSize, nil
}

// FetchAndParseIPA fetches an IPA from a URL and extracts metadata
func FetchAndParseIPA(ctx context.Context, url string, client *http.Client) (*IPAData, error) {
	zr, actualSize, err := OpenRemoteZip(ctx, url, client, 0)
	if err != nil {
		return nil, err
	}

	fileSizeStr := fmt.Sprintf("%.2f MB", float64(actualSize)/1024/1024)

	// First pass: try to find Info.plist in the standard location to avoid iterating through thousands of files
	var lastParseErr error
	for _, file := range zr.File {
		if infoPlistRegex.MatchString(file.Name) {
			data, err := parseInfoPlist(file, url, actualSize, fileSizeStr, zr)
			if err == nil {
				return data, nil
			}
			lastParseErr = err
			slog.Warn("Failed to parse Info.plist in standard location, falling back", "path", file.Name, "error", err)
		}
	}

	if lastParseErr != nil {
		return nil, fmt.Errorf("failed to parse Info.plist: %w", lastParseErr)
	}

	return nil, fmt.Errorf("Info.plist not found in the IPA")
}

func parseInfoPlist(file *zip.File, url string, actualSize int64, fileSizeStr string, zr *zip.Reader) (*IPAData, error) {
	rc, err := file.Open()
	if err != nil {
		return nil, fmt.Errorf("failed to open %s: %v", file.Name, err)
	}
	defer rc.Close()

	buf := new(bytes.Buffer)
	_, err = io.Copy(buf, rc)
	if err != nil {
		return nil, fmt.Errorf("failed to read %s: %v", file.Name, err)
	}

	var plistData map[string]interface{}
	_, err = plist.Unmarshal(buf.Bytes(), &plistData)
	if err != nil {
		return nil, fmt.Errorf("failed to parse Info.plist: %v", err)
	}

	return &IPAData{
		Name:     getString(plistData, "CFBundleName", getString(plistData, "CFBundleDisplayName", "Unknown")),
		Version:  getString(plistData, "CFBundleShortVersionString", "Unknown"),
		Build:    getString(plistData, "CFBundleVersion", "Unknown"),
		BundleID: getString(plistData, "CFBundleIdentifier", "Unknown"),
		URL:      url,
		FileSize: fileSizeStr,
		RawSize:  actualSize,
		IconPath: findBestIcon(plistData, zr),
	}, nil
}

// ExtractIcon extracts a specific file from the IPA
func ExtractIcon(ctx context.Context, urlStr string, iconPath string, client *http.Client, knownSize int64) ([]byte, string, error) {
	zr, _, err := OpenRemoteZip(ctx, urlStr, client, knownSize)
	if err != nil {
		return nil, "", err
	}

	for _, file := range zr.File {
		if file.Name == iconPath {
			rc, err := file.Open()
			if err != nil {
				return nil, "", err
			}
			// Fix Apple's "CgBI" optimized PNGs
			if strings.HasSuffix(strings.ToLower(iconPath), ".png") {
				data, err := io.ReadAll(rc)
				if err != nil {
					return nil, "", err
				}
				outBuf := new(bytes.Buffer)
				err = iospng.PngRevertOptimization(bytes.NewReader(data), outBuf)
				if err == nil {
					return outBuf.Bytes(), "image/png", nil
				} else {
					slog.Warn("Could not de-crush PNG", "path", iconPath, "error", err)
					return data, "image/png", nil
				}
			}

			// For non-PNG or failed de-crush, stream the data
			buf := new(bytes.Buffer)
			_, err = io.Copy(buf, rc)
			if err != nil {
				return nil, "", err
			}

			contentType := "image/png"
			if strings.HasSuffix(strings.ToLower(iconPath), ".jpg") || strings.HasSuffix(strings.ToLower(iconPath), ".jpeg") {
				contentType = "image/jpeg"
			}
			return buf.Bytes(), contentType, nil
		}
	}

	return nil, "", fmt.Errorf("icon not found")
}

func findBestIcon(plistData map[string]interface{}, zr *zip.Reader) string {
	fileMap := make(map[string]bool)
	for _, f := range zr.File {
		fileMap[f.Name] = true
	}

	appFolder := ""
	for _, f := range zr.File {
		if strings.HasPrefix(f.Name, "Payload/") && strings.Contains(f.Name, ".app/Info.plist") {
			idx := strings.Index(f.Name, ".app/Info.plist")
			appFolder = f.Name[:idx+5]
			break
		}
	}

	if appFolder == "" {
		return ""
	}

	var iconFiles []string
	extractFromIconsDict := func(dict interface{}) {
		if d, ok := dict.(map[string]interface{}); ok {
			if primary, ok := d["CFBundlePrimaryIcon"].(map[string]interface{}); ok {
				if files, ok := primary["CFBundleIconFiles"].([]interface{}); ok {
					for _, f := range files {
						if s, ok := f.(string); ok {
							iconFiles = append(iconFiles, s)
						}
					}
				}
			}
		}
	}

	extractFromIconsDict(plistData["CFBundleIcons"])
	extractFromIconsDict(plistData["CFBundleIcons~ipad"])

	if files, ok := plistData["CFBundleIconFiles"].([]interface{}); ok {
		for _, f := range files {
			if s, ok := f.(string); ok {
				iconFiles = append(iconFiles, s)
			}
		}
	}

	if f, ok := plistData["CFBundleIconFile"].(string); ok {
		iconFiles = append(iconFiles, f)
	}

	suffixes := []string{"@3x.png", "@2x.png", ".png", "@3x~iphone.png", "@2x~iphone.png", "~iphone.png", "@3x~ipad.png", "@2x~ipad.png", "~ipad.png"}

	for i := len(iconFiles) - 1; i >= 0; i-- {
		baseName := iconFiles[i]
		for _, s := range suffixes {
			target := appFolder + baseName + s
			if strings.HasSuffix(baseName, ".png") {
				target = appFolder + baseName
			}
			if fileMap[target] {
				return target
			}
		}
	}

	fallbacks := []string{
		"AppIcon60x60@3x.png", "AppIcon60x60@2x.png", "AppIcon40x40@3x.png", "AppIcon40x40@2x.png",
		"Icon-60@3x.png", "Icon-60@2x.png", "Icon-76@2x.png", "Icon-76.png",
		"Icon@3x.png", "Icon@2x.png", "Icon.png",
	}
	for _, fb := range fallbacks {
		if fileMap[appFolder+fb] {
			return appFolder + fb
		}
	}

	for _, f := range zr.File {
		if strings.HasPrefix(f.Name, appFolder) && strings.HasSuffix(f.Name, ".png") {
			lowerName := strings.ToLower(f.Name)
			if strings.Contains(lowerName, "appicon") || (strings.Contains(lowerName, "icon") && !strings.Contains(lowerName, "launch")) {
				return f.Name
			}
		}
	}

	return ""
}

func getString(m map[string]interface{}, key string, defaultValue string) string {
	if v, ok := m[key]; ok {
		if s, ok := v.(string); ok {
			return s
		}
	}
	return defaultValue
}