package main

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"

	"github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{}
var wsBroadcast = make(chan []byte, 100)

func wsHandler(responseWriter http.ResponseWriter, request *http.Request) {
	conn, err := upgrader.Upgrade(responseWriter, request, nil)
	if err != nil {
		fmt.Println("Error during connection upgrade:", err)
		return
	}

	go wsHandleRead(conn)
	wsHandleWrite(conn)
}

func wsHandleRead(conn *websocket.Conn) {
	log.Printf("Starting read handler")
	for {
		messageType, packet, err := conn.ReadMessage()
		if err != nil {
			fmt.Println("Error during message reading:", err)
			return
		}
		log.Printf("Received: %v %s", messageType, packet)
	}
}

func wsHandleWrite(conn *websocket.Conn) {
	log.Println("Starting write handler")
	for {
		packet := <-wsBroadcast
		log.Printf("Broadcasting: %s", packet)
		err := conn.WriteMessage(websocket.TextMessage, packet)
		if err != nil {
			fmt.Println("Error during message writing:", err)
			return
		}
	}
}

type DownloadReq struct {
	Link string `json:"link"`
}

func handleDownload(responseWriter http.ResponseWriter, request *http.Request) {
	body, err := io.ReadAll(request.Body)
	if err != nil {
		log.Printf("Error reading request body: %v", err)
		http.Error(responseWriter, "Error reading request body", http.StatusBadRequest)
		return
	}
	defer request.Body.Close()

	req := DownloadReq{}
	err = json.Unmarshal(body, &req)
	if err != nil {
		log.Printf("Error parsing JSON: %v", err)
		http.Error(responseWriter, "Error parsing JSON", http.StatusBadRequest)
		return
	}

	log.Printf("Received download request: %s", req.Link)
	wsBroadcast <- []byte(req.Link)
}

func main() {
	log.SetFlags(log.Lmicroseconds)

	http.HandleFunc("/ws", wsHandler)
	http.HandleFunc("/download", handleDownload)
	log.Println("Server starting on :8080")
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		log.Println("Error starting server:", err)
	}
}