package main

import (
    "crypto/md5"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "os"
    "path/filepath"
    "sync"
    "time"
    "strings"
    "io/ioutil"
    "image/png"

    "github.com/boombuler/barcode"
    "github.com/boombuler/barcode/qr"
)

const (
    imageDir    = "C:\\bilder\\"
    qrDir       = "C:\\bilder\\qr\\"
    webServerIP = "localhost"
    webServerPort = "5000"
    scanInterval = 5 * time.Second
)

var (
    scannedFiles   = make(map[string]struct{})
    scannedFilesMu sync.Mutex
)

func main() {
    // Starte den Hintergrund-Scan-Prozess
    go startScanProcess()

    // Starte den Webserver
    startWebServer()
}

func startScanProcess() {
    ticker := time.NewTicker(scanInterval)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            scanForNewImages()
        }
    }
}

func scanForNewImages() {
    files, err := ioutil.ReadDir(imageDir)
    if err != nil {
        fmt.Println("Fehler beim Lesen des Bilderverzeichnisses:", err)
        return
    }

    for _, file := range files {
        if file.IsDir() {
            continue
        }

        filename := file.Name()

        scannedFilesMu.Lock()
        _, alreadyScanned := scannedFiles[filename]
        scannedFilesMu.Unlock()

        if !alreadyScanned {
            // Erzeuge MD5-Hash-Code und benenne das Bild um
            if hashStr := generateMD5Hash(filepath.Join(imageDir, filename)); hashStr != "" {
                scannedFilesMu.Lock()
                scannedFiles[filename] = struct{}{}
                scannedFilesMu.Unlock()

                // Erzeuge QR-Code mit dem Pfad
                qrCodeURL := fmt.Sprintf("http://%s:%s/api/view/%s", webServerIP, webServerPort, hashStr)
                qrPath := filepath.Join(qrDir, hashStr+".png")
                generateQRCode(qrCodeURL, qrPath)


            }
        }
    }
}


func generateMD5Hash(filePath string) string {
    // oeffne die Datei
    file, err := os.Open(filePath)
    if err != nil {
        fmt.Println("Fehler beim Oeffnen der Datei:", err)
        return ""
    }


    // Berechne den MD5-Hash
    hash := md5.New()
    if _, err := io.Copy(hash, file); err != nil {
        fmt.Println("Fehler beim Berechnen des MD5-Hashes:", err)
        return ""
    }

    file.Close()

    // Konvertiere den Hash in einen hexadezimalen String
    hashStr := hex.EncodeToString(hash.Sum(nil))

    // Benenne die Originalbilddatei in ihren MD5-Hash um
    newImagePath := filepath.Join(imageDir, hashStr)
    err = os.Rename(filePath, newImagePath)
    if err != nil {
        fmt.Println("Fehler beim Umbenennen der Datei:", err)
        return ""
    }

    return hashStr
}

func generateQRCode(qrCodeURL, qrPath string) {
    // Erzeuge den QR-Code
    qrCode, err := qr.Encode(qrCodeURL, qr.L, qr.Auto)
    if err != nil {
        fmt.Println("Fehler beim Erstellen des QR-Codes:", err)
        return
    }

    // Erzeuge das QR-Code-Bild
    qrCodeImage, err := barcode.Scale(qrCode, 200, 200)
    if err != nil {
        fmt.Println("Fehler beim Skalieren des QR-Codes:", err)
        return
    }

    // Speichere das QR-Code-Bild
    qrCodeFile, err := os.Create(qrPath)
    if err != nil {
        fmt.Println("Fehler beim Erstellen des QR-Code-Bildes:", err)
        return
    }
    defer qrCodeFile.Close()

    if err := png.Encode(qrCodeFile, qrCodeImage); err != nil {
        fmt.Println("Fehler beim Speichern des QR-Codes:", err)
        return
    }
}

func startWebServer() {
    http.HandleFunc("/api/view/", viewHandler)
    addr := webServerIP + ":" + webServerPort
    fmt.Println("Webserver gestartet auf", addr)
    http.ListenAndServe(addr, nil)
}

func viewHandler(w http.ResponseWriter, r *http.Request) {
    // Holen Sie den MD5-Hash-Code aus der URL
    hashcode := strings.TrimPrefix(r.URL.Path, "/api/view/")
    imagePath := filepath.Join(imageDir, hashcode)

    // Senden Sie das Bild als Antwort
    http.ServeFile(w, r, imagePath)
}