Skripsi_Valentino_5103022014/backend/controllers/hardwarecontroller.go

package controllers

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"strconv" // Digunakan untuk mengubah teks Watt menjadi angka
	"strings" // Digunakan untuk manipulasi string (ToUpper/Trim)
	"time"

	"s-class-backend/config" // Import database
	"s-class-backend/models" // Import models untuk query database

	mqtt "github.com/eclipse/paho.mqtt.golang"
	"github.com/gin-gonic/gin"
)

// --- STRUKTUR DATA REQUEST ---
type DeviceControlRequest struct {
	Device string `json:"device"`
	Action string `json:"action"`
}

type VerifyRequest struct {
	Token string `json:"token"`
}

type GlobalPowerRequest struct {
	Action string `json:"action"` // "on" atau "off"
}

// =========================================================================
// CACHE STATUS HARDWARE (Mengingat status terakhir perangkat untuk Web Admin)
// =========================================================================
var DeviceStatusCache = map[string]string{
	"lampu1":    "off",
	"lampu2":    "off",
	"ac":        "off",
	"projector": "off",
}

// =========================================================================
// FUNGSI 1: VERIFIKASI TOKEN & KODE MATA KULIAH (DOUBLE-LAYER PROTECTION)
// =========================================================================
func VerifyHardwareCode(c *gin.Context) {
	var req VerifyRequest

	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Format token tidak valid"})
		return
	}

	tokenInput := strings.ToUpper(strings.TrimSpace(req.Token))
	loc, _ := time.LoadLocation("Asia/Jakarta")
	sekarang := time.Now().In(loc)
	sisaMenit := 0
	isTokenValid := false

	// =========================================================
	// 1. PENGECEKAN KELOMPOK TOKEN MASTER (Tanpa Cek Waktu)
	// =========================================================
	if tokenInput == "CS2026" {
		fmt.Printf("[VERIFY] Master Token CS digunakan\n")
		sisaMenit = 60
		isTokenValid = true
	} else if tokenInput == "ADM999" {
		fmt.Printf("[VERIFY] Master Token Admin digunakan\n")
		sisaMenit = 1440 // 24 Jam
		isTokenValid = true
	} else {
		// =========================================================
		// 2. CEK TOKEN BOOKING VIA WEB (6 DIGIT)
		// =========================================================
		var booking models.Booking
		errBooking := config.DB.First(&booking, "redeem_code = ? AND status = 'Approved'", tokenInput).Error

		if errBooking == nil {
			if booking.StartTime.Format("2006-01-02") != sekarang.Format("2006-01-02") {
				c.JSON(http.StatusForbidden, gin.H{"error": "Peminjaman bukan untuk hari ini!"})
				return
			}

			toleransiMasuk := booking.StartTime.Add(-15 * time.Minute)
			if sekarang.Before(toleransiMasuk) {
				c.JSON(http.StatusForbidden, gin.H{"error": "Belum waktunya. Bisa masuk 15 menit sebelum kelas!"})
				return
			}
			if sekarang.After(booking.EndTime) {
				c.JSON(http.StatusForbidden, gin.H{"error": "Waktu peminjaman sudah habis!"})
				return
			}

			sisaMenit = int(booking.EndTime.Sub(sekarang).Minutes())
			if sisaMenit <= 0 {
				sisaMenit = 1
			}
			isTokenValid = true

		} else {
			// =========================================================
			// 3. CEK KODE MATA KULIAH DENGAN DOUBLE-LAYER PROTECTION
			// =========================================================
			var reqSchedule models.ClassSchedule
			// Cari apakah Kode MK yang diketik eksis di database (contoh: "EE153")
			errSchedule := config.DB.First(&reqSchedule, "kode_mk = ?", tokenInput).Error

			if errSchedule == nil {
				// PROTEKSI LAPIS 1: Cek apakah ada yang sedang Booking via Web sekarang
				var countBookingAktif int64
				config.DB.Model(&models.Booking{}).Where(
					"room_id = ? AND status = 'Approved' AND start_time <= ? AND end_time >= ?",
					reqSchedule.RoomID, sekarang, sekarang,
				).Count(&countBookingAktif)

				if countBookingAktif > 0 {
					c.JSON(http.StatusConflict, gin.H{"error": "Akses Ditolak: Ruangan sedang dipakai peminjam resmi (Web)!"})
					return
				}

				// PROTEKSI LAPIS 2: Cek apakah ada JADWAL KELAS LAIN yang sedang berjalan di jam ini
				// Ambil nama hari ini dalam Bahasa Indonesia
				hariMap := map[time.Weekday]string{
					time.Sunday: "Minggu", time.Monday: "Senin", time.Tuesday: "Selasa",
					time.Wednesday: "Rabu", time.Thursday: "Kamis", time.Friday: "Jumat", time.Saturday: "Sabtu",
				}
				hariIni := hariMap[sekarang.Weekday()]
				jamSekarang := sekarang.Format("15:04:05")

				var activeClass models.ClassSchedule
				errActive := config.DB.Where(
					"room_id = ? AND hari = ? AND jam_mulai <= ? AND jam_selesai >= ?",
					reqSchedule.RoomID, hariIni, jamSekarang, jamSekarang,
				).First(&activeClass).Error

				if errActive == nil {
					// Ada kelas yang sedang berlangsung saat ini.
					// Cek apakah kelas tersebut BERBEDA dengan Kode MK yang diinputkan pengguna
					// 🌟 PERBAIKAN: Ubah KodeMk menjadi KodeMK (K huruf besar)
					if activeClass.KodeMK != reqSchedule.KodeMK {
						c.JSON(http.StatusConflict, gin.H{
							// 🌟 PERBAIKAN: Ubah NamaMk menjadi NamaMK (K huruf besar)
							"error": "Akses Ditolak: Ruangan sedang digunakan oleh jadwal kelas " + activeClass.NamaMK,
						})
						return
					}
					// Jika kodenya SAMA (Dosen menginputkan kodenya di jam yang memang miliknya), abaikan & beri izin masuk.
				}

				// JIKA LOLOS SEMUA PROTEKSI: Berikan akses waktu berdasarkan jumlah SKS
				// 🌟 PERBAIKAN: Pastikan ini sesuai dengan struct di models (JumlahSks atau JumlahSKS)
				durasiMenit := reqSchedule.JumlahSks * 50
				if durasiMenit <= 0 {
					durasiMenit = 100 // Nilai aman (default 2 SKS) jika database kosong
				}

				sisaMenit = durasiMenit
				isTokenValid = true
			}
		}

		if !isTokenValid {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Token Web atau Kode MK tidak ditemukan!"})
			return
		}
	}

	// =========================================================
	// 4. JIKA VALID, BUKA GEMBOK VIA MQTT & HTTP LOKAL
	// =========================================================
	DeviceStatusCache["lampu1"] = "on"
	DeviceStatusCache["lampu2"] = "on"

	broker := os.Getenv("MQTT_BROKER")
	user := os.Getenv("MQTT_USER")
	pass := os.Getenv("MQTT_PASSWORD")

	opts := mqtt.NewClientOptions()
	opts.AddBroker(broker)
	opts.SetUsername(user)
	opts.SetPassword(pass)
	opts.SetClientID(fmt.Sprintf("Golang-Auth-%d", time.Now().Unix()))

	client := mqtt.NewClient(opts)
	if tokenMQTT := client.Connect(); tokenMQTT.Wait() && tokenMQTT.Error() == nil {
		client.Publish("sclass/d101/auth", 0, true, "UNLOCK").Wait()
		// Opsional: Jika masih mengandalkan MQTT untuk lampu
		client.Publish("sclass/d101/lampu1", 0, false, "on").Wait()
		client.Publish("sclass/d101/lampu2", 0, false, "on").Wait()
		client.Disconnect(250)
		fmt.Printf("[MQTT] Perintah UNLOCK dan ON dikirim (Sisa Menit: %d)\n", sisaMenit)
	} else {
		fmt.Printf("[MQTT ERROR] Gagal menghubungi broker: %v\n", tokenMQTT.Error())
	}

	c.JSON(http.StatusOK, gin.H{
		"status":           "success",
		"message":          "Akses Diberikan",
		"duration_minutes": sisaMenit,
	})
}

// =========================================================================
// FUNGSI 2: KONTROL DEVICE VIA HOME ASSISTANT & MQTT
// =========================================================================
func ControlHardware(c *gin.Context) {
	var req DeviceControlRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Format data tidak valid"})
		return
	}

	if req.Device == "auth" {
		broker := os.Getenv("MQTT_BROKER")
		user := os.Getenv("MQTT_USER")
		pass := os.Getenv("MQTT_PASSWORD")

		opts := mqtt.NewClientOptions().AddBroker(broker).SetUsername(user).SetPassword(pass).SetClientID(fmt.Sprintf("Golang-Lock-%d", time.Now().Unix()))
		client := mqtt.NewClient(opts)
		if token := client.Connect(); token.Wait() && token.Error() == nil {
			client.Publish("sclass/d101/auth", 0, true, req.Action).Wait()
			client.Disconnect(250)
			fmt.Println("[MQTT] Status Gembok Relay diubah menjadi:", req.Action)
		} else {
			fmt.Println("[MQTT ERROR] Gagal terhubung saat mencoba mengunci relay.")
		}
		c.JSON(http.StatusOK, gin.H{"status": "success", "message": "Gembok " + req.Action})
		return
	}

	if req.Device == "lampu1" || req.Device == "lampu2" {
		broker := os.Getenv("MQTT_BROKER")
		user := os.Getenv("MQTT_USER")
		pass := os.Getenv("MQTT_PASSWORD")

		opts := mqtt.NewClientOptions()
		opts.AddBroker(broker)
		opts.SetUsername(user)
		opts.SetPassword(pass)
		opts.SetClientID(fmt.Sprintf("Golang-SCLASS-%d", time.Now().Unix()))

		client := mqtt.NewClient(opts)
		if token := client.Connect(); token.Wait() && token.Error() != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Golang gagal terhubung ke MQTT Broker"})
			return
		}
		defer client.Disconnect(250)

		topic := fmt.Sprintf("sclass/d101/%s", req.Device)
		token := client.Publish(topic, 0, false, req.Action)
		token.Wait()

		DeviceStatusCache[req.Device] = req.Action
		c.JSON(http.StatusOK, gin.H{"status": "success", "message": fmt.Sprintf("Berhasil %s ke %s", req.Action, req.Device)})
		return
	}

	if req.Device == "ac" || req.Device == "projector" {
		haURL := os.Getenv("HA_URL")
		haToken := os.Getenv("HA_TOKEN")
		var entityID string

		switch req.Device {
		case "ac":
			if req.Action == "on" {
				entityID = "scene.ac_d101_on"
			} else {
				entityID = "scene.ac_d101_off"
			}
		case "projector":
			if req.Action == "on" {
				entityID = "scene.projector_d101_on"
			} else {
				entityID = "scene.projector_d101_off"
			}
		}

		apiURL := fmt.Sprintf("%s/api/services/scene/turn_on", haURL)
		payload := map[string]string{"entity_id": entityID}
		jsonPayload, _ := json.Marshal(payload)

		reqHA, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(jsonPayload))
		if err == nil {
			reqHA.Header.Set("Authorization", "Bearer "+haToken)
			reqHA.Header.Set("Content-Type", "application/json")
			httpClient := &http.Client{Timeout: 5 * time.Second}
			resp, _ := httpClient.Do(reqHA)
			if resp != nil {
				resp.Body.Close()
			}
		}

		DeviceStatusCache[req.Device] = req.Action
		c.JSON(http.StatusOK, gin.H{"status": "success", "message": "Scene dipicu: " + entityID})
		return
	}

	c.JSON(http.StatusBadRequest, gin.H{"error": "Device tidak dikenali"})
}

// =========================================================================
// HELPER 1 & 2: HTTP GET KE HOME ASSISTANT
// =========================================================================
func fetchHAState(haURL string, haToken string, entityID string) float64 {
	apiURL := fmt.Sprintf("%s/api/states/%s", haURL, entityID)

	req, _ := http.NewRequest("GET", apiURL, nil)
	req.Header.Set("Authorization", "Bearer "+haToken)
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{Timeout: 3 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return 0
	}
	defer resp.Body.Close()

	var result map[string]interface{}
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return 0
	}

	stateStr, ok := result["state"].(string)
	if !ok {
		return 0
	}

	val, _ := strconv.ParseFloat(stateStr, 64)
	return val
}

func fetchHAStringState(haURL string, haToken string, entityID string) string {
	apiURL := fmt.Sprintf("%s/api/states/%s", haURL, entityID)

	req, _ := http.NewRequest("GET", apiURL, nil)
	req.Header.Set("Authorization", "Bearer "+haToken)
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{Timeout: 3 * time.Second}
	resp, err := client.Do(req)
	if err != nil {
		return "off"
	}
	defer resp.Body.Close()

	var result map[string]interface{}
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return "off"
	}

	stateStr, ok := result["state"].(string)
	if !ok {
		return "off"
	}

	return stateStr
}

// =========================================================================
// FUNGSI 3: MENDAPATKAN STATUS DAYA
// =========================================================================
func GetPowerStatus(c *gin.Context) {
	haURL := os.Getenv("HA_URL")
	haToken := os.Getenv("HA_TOKEN")

	powerUmum := fetchHAState(haURL, haToken, "sensor.wifi_smart_meter_pro_power")
	powerAC1 := fetchHAState(haURL, haToken, "sensor.wifi_smart_meter_pro_2_power")
	powerAC2 := fetchHAState(haURL, haToken, "sensor.wifi_smart_meter_pro_3_power")

	c.JSON(http.StatusOK, gin.H{
		"umum": powerUmum,
		"ac1":  powerAC1,
		"ac2":  powerAC2,
	})
}

// =========================================================================
// FUNGSI 4: GLOBAL POWER CONTROL
// =========================================================================
func GlobalPowerControl(c *gin.Context) {
	var req GlobalPowerRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Format data tidak valid"})
		return
	}

	haURL := os.Getenv("HA_URL")
	haToken := os.Getenv("HA_TOKEN")

	service := "turn_off"
	if req.Action == "on" {
		service = "turn_on"
	}
	apiURL := fmt.Sprintf("%s/api/services/switch/%s", haURL, service)

	mcbs := []string{
		"switch.wifi_smart_meter_pro_switch",   // Umum
		"switch.wifi_smart_meter_pro_2_switch", // AC1
		"switch.wifi_smart_meter_pro_3_switch", // AC2
	}

	for i, mcb := range mcbs {
		payload := map[string]string{"entity_id": mcb}
		jsonPayload, _ := json.Marshal(payload)

		reqHA, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(jsonPayload))
		if err == nil {
			reqHA.Header.Set("Authorization", "Bearer "+haToken)
			reqHA.Header.Set("Content-Type", "application/json")

			client := &http.Client{Timeout: 5 * time.Second}
			resp, err := client.Do(reqHA)
			if err == nil && resp != nil {
				resp.Body.Close()
			}
		}

		fmt.Printf("[MCB] Sinyal %s dikirim ke %s\n", req.Action, mcb)

		if i < len(mcbs)-1 {
			time.Sleep(1 * time.Second)
		}
	}

	if req.Action == "off" {
		DeviceStatusCache["lampu1"] = "off"
		DeviceStatusCache["lampu2"] = "off"
		DeviceStatusCache["ac"] = "off"
		DeviceStatusCache["projector"] = "off"
	}

	c.JSON(http.StatusOK, gin.H{
		"status":  "success",
		"message": fmt.Sprintf("Seluruh daya ruangan berhasil di-%s secara berurutan", req.Action),
	})
}

// =========================================================================
// FUNGSI 5: SENSOR FUSION FRONTEND
// =========================================================================
func GetHardwareStatus(c *gin.Context) {
	haURL := os.Getenv("HA_URL")
	haToken := os.Getenv("HA_TOKEN")

	mcbUmum := fetchHAStringState(haURL, haToken, "switch.wifi_smart_meter_pro_switch")
	mcbAC1 := fetchHAStringState(haURL, haToken, "switch.wifi_smart_meter_pro_2_switch")

	statusLampu1 := DeviceStatusCache["lampu1"]
	statusLampu2 := DeviceStatusCache["lampu2"]
	statusProyektor := DeviceStatusCache["projector"]
	statusAC := DeviceStatusCache["ac"]

	if mcbUmum == "off" {
		statusLampu1 = "off"
		statusLampu2 = "off"
		statusProyektor = "off"

		DeviceStatusCache["lampu1"] = "off"
		DeviceStatusCache["lampu2"] = "off"
		DeviceStatusCache["projector"] = "off"
	}

	if mcbAC1 == "off" {
		statusAC = "off"
		DeviceStatusCache["ac"] = "off"
	}

	c.JSON(http.StatusOK, gin.H{
		"status": "success",
		"data": map[string]string{
			"lampu1":    statusLampu1,
			"lampu2":    statusLampu2,
			"projector": statusProyektor,
			"ac":        statusAC,
		},
	})
}