main.go

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"path"
	"strings"
	"time"
)


func main() {
	// Handler untuk download dengan path
	http.HandleFunc("/download/", downloadPathHandler)
	
	// Handler untuk download dengan query parameter (backward compatibility)
	http.HandleFunc("/download", downloadQueryHandler)
	
	// Handler untuk serve HTML generator
	http.HandleFunc("/", serveHTMLHandler)
	
	log.Println("🚀 Server running on http://localhost:7860")
	log.Println("📥 Generator: http://localhost:7860")
	log.Println("📥 Download: http://localhost:7860/download/{domain}/{path}")
	log.Println("📥 Download (with .mp4): http://localhost:7860/download/mp4/{domain}/{path}")
	log.Fatal(http.ListenAndServe(":7860", nil))
}

// Handler untuk serve HTML file
func serveHTMLHandler(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/" {
		http.NotFound(w, r)
		return
	}
	http.ServeFile(w, r, "index.html")
}

// Handler untuk download dengan path /download/{domain}/{path} atau /download/mp4/{domain}/{path}
func downloadPathHandler(w http.ResponseWriter, r *http.Request) {
	// Ambil path setelah /download/
	pathStr := strings.TrimPrefix(r.URL.Path, "/download/")
	
	// Pisahkan berdasarkan slash
	parts := strings.Split(pathStr, "/")
	
	if len(parts) < 2 {
		http.Error(w, "Invalid URL format. Use: /download/{domain}/{path} or /download/mp4/{domain}/{path}", http.StatusBadRequest)
		return
	}
	
	var targetURL string
	hasMp4Format := false
	
	// Cek apakah ada format mp4 di awal (penanda bahwa URL asli sudah ada .mp4)
	if parts[0] == "mp4" {
		// Format: /download/mp4/{domain}/{path} → URL asli sudah ada .mp4
		hasMp4Format = true
		parts = parts[1:] // Hapus "mp4" dari array
	}
	
	// Ambil domain (parts[0]) dan path (sisanya)
	if len(parts) < 2 {
		http.Error(w, "Invalid URL format. Need domain and path", http.StatusBadRequest)
		return
	}
	
	domain := parts[0]
	pathParts := parts[1:]
	pathStr2 := strings.Join(pathParts, "/")
	
	// Bangun URL target berdasarkan format
	if hasMp4Format {
		// Ada /mp4/ di URL → URL asli sudah memiliki .mp4, langsung gunakan
		targetURL = "https://" + domain + "/" + pathStr2
	} else {
		// Tidak ada /mp4/ di URL → URL asli tidak ada .mp4
		// HAPUS .mp4 dari akhir path (karena proxy URL ditambahi .mp4 untuk remote upload)
		if strings.HasSuffix(pathStr2, ".mp4") {
			pathStr2 = strings.TrimSuffix(pathStr2, ".mp4")
		}
		targetURL = "https://" + domain + "/" + pathStr2
	}
	
	log.Printf("📥 HasMp4Format: %v, Target URL: %s", hasMp4Format, targetURL)
	
	// Proxy download STREAMING dengan HEAD request
	downloadProxyStreamWithHead(w, r, targetURL)
}

// Handler untuk download dengan query parameter (backward compatibility)
func downloadQueryHandler(w http.ResponseWriter, r *http.Request) {
	encodedURL := r.URL.Query().Get("url")
	if encodedURL == "" {
		http.Error(w, "Parameter 'url' required", http.StatusBadRequest)
		return
	}
	
	targetURL, err := url.QueryUnescape(encodedURL)
	if err != nil {
		http.Error(w, "Invalid URL", http.StatusBadRequest)
		return
	}
	
	log.Printf("📥 Downloading: %s", targetURL)
	downloadProxyStreamWithHead(w, r, targetURL)
}

// Fungsi proxy download dengan HEAD request terlebih dahulu
func downloadProxyStreamWithHead(w http.ResponseWriter, r *http.Request, targetURL string) {
	// Ambil nama file dari URL
	filename := path.Base(targetURL)
	if !strings.HasSuffix(filename, ".mp4") {
		filename = "video.mp4"
	}
	
	log.Printf("📥 Streaming: %s", targetURL)
	
	// STEP 1: HEAD request untuk mendapatkan metadata
	headReq, err := http.NewRequest("HEAD", targetURL, nil)
	if err != nil {
		http.Error(w, "Failed to create HEAD request", http.StatusInternalServerError)
		return
	}
	
	// Set headers untuk HEAD request
	headReq.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36")
	headReq.Header.Set("Referer", targetURL)
	headReq.Header.Set("Accept", "*/*")
	headReq.Header.Set("Accept-Language", "en-GB,en-US;q=0.9,en;q=0.8")
	headReq.Header.Set("Accept-Encoding", "gzip, deflate, br")
	headReq.Header.Set("Cache-Control", "no-cache")
	headReq.Header.Set("Pragma", "no-cache")
	headReq.Header.Set("Sec-Fetch-Dest", "video")
	headReq.Header.Set("Sec-Fetch-Mode", "no-cors")
	headReq.Header.Set("Sec-Fetch-Site", "same-origin")
	headReq.Header.Set("Connection", "keep-alive")
	
	client := &http.Client{
		Timeout: 30 * time.Second,
		Transport: &http.Transport{
			MaxIdleConns:        100,
			MaxIdleConnsPerHost: 100,
			IdleConnTimeout:     90 * time.Second,
			DisableCompression:  false,
			ResponseHeaderTimeout: 30 * time.Second,
		},
	}
	
	// Eksekusi HEAD request
	headResp, err := client.Do(headReq)
	if err != nil {
		log.Printf("⚠️ HEAD request failed: %v, fallback to normal GET", err)
		// Fallback ke GET biasa
		downloadProxyStream(w, r, targetURL)
		return
	}
	defer headResp.Body.Close()
	
	// Ambil Content-Length dari HEAD
	contentLength := headResp.ContentLength
	log.Printf("📊 HEAD response - Content-Length: %d bytes (%.2f MB)", contentLength, float64(contentLength)/(1024*1024))
	
	// STEP 2: GET request untuk streaming
	req, err := http.NewRequest("GET", targetURL, nil)
	if err != nil {
		http.Error(w, "Failed to create request", http.StatusInternalServerError)
		return
	}
	
	// Set headers lengkap (sama seperti sebelumnya)
	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36")
	req.Header.Set("Referer", targetURL)
	req.Header.Set("Accept", "*/*")
	req.Header.Set("Accept-Language", "en-GB,en-US;q=0.9,en;q=0.8")
	req.Header.Set("Accept-Encoding", "gzip, deflate, br")
	req.Header.Set("Cache-Control", "no-cache")
	req.Header.Set("Pragma", "no-cache")
	req.Header.Set("Sec-Fetch-Dest", "video")
	req.Header.Set("Sec-Fetch-Mode", "no-cors")
	req.Header.Set("Sec-Fetch-Site", "same-origin")
	req.Header.Set("Connection", "keep-alive")
	
	// Forward Range header jika ada
	if rangeHeader := r.Header.Get("Range"); rangeHeader != "" {
		req.Header.Set("Range", rangeHeader)
	}
	
	// Eksekusi GET request
	resp, err := client.Do(req)
	if err != nil {
		http.Error(w, fmt.Sprintf("Download failed: %v", err), http.StatusInternalServerError)
		log.Printf("❌ Error: %v", err)
		return
	}
	defer resp.Body.Close()
	
	// Cek status code
	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusPartialContent {
		http.Error(w, fmt.Sprintf("Status: %d", resp.StatusCode), resp.StatusCode)
		log.Printf("❌ Status: %d", resp.StatusCode)
		return
	}
	
	log.Printf("✅ Connected, Status: %d", resp.StatusCode)
	
	// Set header untuk download
	w.Header().Set("Content-Type", "video/mp4")
	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
	
	// Gunakan Content-Length dari HEAD (lebih akurat)
	if contentLength > 0 {
		w.Header().Set("Content-Length", fmt.Sprintf("%d", contentLength))
	} else if resp.ContentLength > 0 {
		w.Header().Set("Content-Length", fmt.Sprintf("%d", resp.ContentLength))
	}
	
	// Forward header lainnya
	if resp.Header.Get("Accept-Ranges") != "" {
		w.Header().Set("Accept-Ranges", resp.Header.Get("Accept-Ranges"))
	}
	if resp.Header.Get("Content-Range") != "" {
		w.Header().Set("Content-Range", resp.Header.Get("Content-Range"))
	}
	
	// Set status code
	w.WriteHeader(resp.StatusCode)
	
	// STREAMING: Kirim langsung
	buf := make([]byte, 64*1024) // 64KB buffer (lebih besar)
	written, err := io.CopyBuffer(w, resp.Body, buf)
	if err != nil {
		log.Printf("❌ Error streaming: %v", err)
		return
	}
	
	log.Printf("✅ Stream complete: %s (%.2f MB)", filename, float64(written)/(1024*1024))
}

// Fallback: Proxy streaming tanpa HEAD (untuk backup)
func downloadProxyStream(w http.ResponseWriter, r *http.Request, targetURL string) {
	filename := path.Base(targetURL)
	if !strings.HasSuffix(filename, ".mp4") {
		filename = "video.mp4"
	}
	
	log.Printf("📥 Streaming (fallback): %s", targetURL)
	
	req, err := http.NewRequest("GET", targetURL, nil)
	if err != nil {
		http.Error(w, "Failed to create request", http.StatusInternalServerError)
		return
	}
	
	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36")
	req.Header.Set("Referer", targetURL)
	req.Header.Set("Accept", "*/*")
	req.Header.Set("Accept-Language", "en-GB,en-US;q=0.9,en;q=0.8")
	req.Header.Set("Accept-Encoding", "gzip, deflate, br")
	req.Header.Set("Cache-Control", "no-cache")
	req.Header.Set("Pragma", "no-cache")
	req.Header.Set("Sec-Fetch-Dest", "video")
	req.Header.Set("Sec-Fetch-Mode", "no-cors")
	req.Header.Set("Sec-Fetch-Site", "same-origin")
	req.Header.Set("Connection", "keep-alive")
	
	if rangeHeader := r.Header.Get("Range"); rangeHeader != "" {
		req.Header.Set("Range", rangeHeader)
	}
	
	client := &http.Client{
		Timeout: 15 * time.Minute,
		Transport: &http.Transport{
			MaxIdleConns:        100,
			MaxIdleConnsPerHost: 100,
			IdleConnTimeout:     90 * time.Second,
			DisableCompression:  false,
			ResponseHeaderTimeout: 30 * time.Second,
		},
	}
	
	resp, err := client.Do(req)
	if err != nil {
		http.Error(w, fmt.Sprintf("Download failed: %v", err), http.StatusInternalServerError)
		log.Printf("❌ Error: %v", err)
		return
	}
	defer resp.Body.Close()
	
	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusPartialContent {
		http.Error(w, fmt.Sprintf("Status: %d", resp.StatusCode), resp.StatusCode)
		log.Printf("❌ Status: %d", resp.StatusCode)
		return
	}
	
	w.Header().Set("Content-Type", "video/mp4")
	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
	
	if resp.ContentLength > 0 {
		w.Header().Set("Content-Length", fmt.Sprintf("%d", resp.ContentLength))
	}
	if resp.Header.Get("Accept-Ranges") != "" {
		w.Header().Set("Accept-Ranges", resp.Header.Get("Accept-Ranges"))
	}
	if resp.Header.Get("Content-Range") != "" {
		w.Header().Set("Content-Range", resp.Header.Get("Content-Range"))
	}
	
	w.WriteHeader(resp.StatusCode)
	
	buf := make([]byte, 64*1024)
	written, err := io.CopyBuffer(w, resp.Body, buf)
	if err != nil {
		log.Printf("❌ Error streaming: %v", err)
		return
	}
	
	log.Printf("✅ Stream complete (fallback): %s (%.2f MB)", filename, float64(written)/(1024*1024))
}