import {
    "github.com/gofiber/contrib/websocket"
}
func main() {
    app := fiber.New(fiber.Config{})

    app.Get("/ws/resetfolder", websocket.New(handleResetFolder))
}

func handleResetFolder(c *websocket.Conn) {
    if err := ResetFolder(c); err != nil {
        log.Println("Error resetting folder:", err)
        c.Close()
    }
}

func ResetFolder(c *websocket.Conn) error {
    // folder is defined in somewhere else
    if err := os.RemoveAll(folder); err != nil {
        return fmt.Errorf("error removing folder %s: %v", folder, err)
    }

    outputMessage("■", c)
    outputMessage("<br/><br/>finished!", c)
    c.Close()

    return nil
}

const [bWSClosed, setWSClosed] = useState(false);
const [bWSOpenedOnce, setWSOpened] = useState(false);

let wsHost = process.env.NEXT_PUBLIC_API_URL;
if (wsHost?.startsWith("http://")) {
    wsHost = "ws" + wsHost?.substring(wsHost.indexOf(":"));
} else if (wsHost?.startsWith("https://")) {
    wsHost = "wss" + wsHost?.substring(wsHost.indexOf(":"));
}

useEffect(() => {
    const socket = new WebSocket(wsHost + 'ws/resetfolder');

    socket.onopen = () => {
        setWSClosed(false);
        setWSOpened(true);
    };

    socket.onmessage = (event) => {
        prevMessageRef.current = prevMessageRef.current + event.data;
        setMessage(prevMessageRef.current);
    };

    socket.onclose = () => {
        setWSClosed(true);
    }

    return () => {
        socket.close();
    };
}, []);

func main() {
    app := fiber.New(fiber.Config{})

    app.Get("/pr/resetfolder", prResetFolder)
}

func prResetFolder(c *fiber.Ctx) error {
    c.Set("Content-Type", "text/plain")
    c.Set("Cache-Control", "no-cache")
    c.Set("Connection", "keep-alive")

    c.Context().SetBodyStreamWriter(func(w *bufio.Writer) {
        folder := filepath.Join(dirResult, strconv.Itoa(report_year))

        ticker := time.NewTicker(1 * time.Minute) // Send heartbeat every 1 min
        defer ticker.Stop()

        done := make(chan struct{})
        go func() {
            for {
                select {
                case <-ticker.C:
                    fmt.Fprintf(w, ".") // Heartbeat to prevent idle
                    w.Flush()
                case <-done:
                    return
                }
            }
        }()

        if err := os.RemoveAll(folder); err != nil {
            fmt.Printf("error removing folder %s: %v\r\n", folder, err)
        }

        fmt.Fprintf(w, "■")
        w.Flush()

        close(done) // Stop ticker when work is done

        fmt.Fprintf(w, "<br/><br/>finished!")

        w.Flush()
    })
    return nil
}

const [bWSClosed, setWSClosed] = useState(false);
const [bWSOpenedOnce, setWSOpened] = useState(false);

useEffect(() => {
    const fetchProgress = async () => {
        const response = await fetch(process.env.NEXT_PUBLIC_API_URL + 'pr/resetfolder');
        const reader = response?.body?.getReader();
        const decoder = new TextDecoder();
        let progressData = '';

        while (true) {
            const result = await reader?.read();
            if (!result) break;
            const { done, value } = result;
            if (done) {
                // console.log("done");
                setWSClosed(true);
                setWSOpened(true);
                break;
            } else {
                console.log("not done");
            }

            progressData += decoder.decode(value, { stream: true });

            prevMessageRef.current = progressData;
            setMessage(prevMessageRef.current);
        }
    };

    fetchProgress();
}, []);