lc_garage/internal/modules/parking-session/service/service.go

package service

import (
	"errors"
	"fmt"
	"math"
	"strings"
	"time"
	"wails-app/internal/dao"
	"wails-app/internal/global"
	"wails-app/internal/modules/parking-session/model/request"
	"wails-app/internal/modules/parking-session/repository"

	"gorm.io/gorm"
)

const (
	PaymentStatusUnpaid = "unpaid"
	PaymentStatusPaid   = "paid"
)

var (
	ErrSessionNotFound         = errors.New("未找到在场停车会话")
	ErrSessionAlreadyOpen      = errors.New("车辆已有在场停车会话")
	ErrSessionAlreadyPaid      = errors.New("停车会话已完成支付")
	ErrSessionAlreadyClosed    = errors.New("停车会话已关闭")
	ErrSessionIdentityConflict = errors.New("车牌与RFID对应不同的在场停车会话")
	ErrSessionAmbiguous        = errors.New("存在多条匹配的在场停车会话")
	ErrSessionIdentifierEmpty  = errors.New("停车会话必须提供车牌、RFID或会话编号")
)

// ParkingSessionService owns the parking-stay lifecycle. It deliberately
// persists to vehicle_record so existing reports and historical data remain
// compatible while callers stop treating the record as an unstructured table.
type ParkingSessionService struct {
	repo *repository.ParkingSessionRepository
}

func NewParkingSessionService() *ParkingSessionService {
	return &ParkingSessionService{repo: &repository.ParkingSessionRepository{}}
}

// FindActiveSession is the domain-facing name used by adapters that do not
// need to know whether the lookup is backed by a transaction.
func (s *ParkingSessionService) FindActiveSession(req request.ResolveActiveSessionRequest) (*dao.VehicleRecord, error) {
	return s.ResolveActiveSession(req)
}

func (s *ParkingSessionService) OpenSession(req request.OpenSessionRequest) (*dao.VehicleRecord, error) {
	if global.GVA_DB == nil {
		return nil, errors.New("数据库未初始化")
	}
	var session *dao.VehicleRecord
	err := global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		var err error
		session, err = s.OpenSessionTx(tx, req)
		return err
	})
	return session, err
}

func (s *ParkingSessionService) MarkPaid(sessionID uint, paymentEntry, paymentMethod string, fee float64) (*dao.VehicleRecord, error) {
	if global.GVA_DB == nil {
		return nil, errors.New("数据库未初始化")
	}
	var session *dao.VehicleRecord
	err := global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		var err error
		session, err = s.MarkPaidTx(tx, sessionID, paymentEntry, paymentMethod, fee)
		return err
	})
	return session, err
}

func (s *ParkingSessionService) CloseSession(req request.CloseSessionRequest) (*dao.VehicleRecord, error) {
	if global.GVA_DB == nil {
		return nil, errors.New("数据库未初始化")
	}
	var session *dao.VehicleRecord
	err := global.GVA_DB.Transaction(func(tx *gorm.DB) error {
		var err error
		session, err = s.CloseSessionTx(tx, req)
		return err
	})
	return session, err
}

func (s *ParkingSessionService) ResolveActiveSession(req request.ResolveActiveSessionRequest) (*dao.VehicleRecord, error) {
	return s.ResolveActiveSessionTx(global.GVA_DB, req)
}

// ResolveActiveSessionTx resolves one active parking session deterministically.
// When both identities are supplied, it refuses to pick an arbitrary session
// if the plate and RFID point to different active records.
func (s *ParkingSessionService) ResolveActiveSessionTx(db *gorm.DB, req request.ResolveActiveSessionRequest) (*dao.VehicleRecord, error) {
	if db == nil {
		return nil, errors.New("数据库未初始化")
	}
	if req.SessionID != 0 {
		session, err := s.repo.FindActiveByIDTx(db, req.SessionID)
		if err == nil {
			return session, nil
		}
		return nil, sessionLookupError(db, req.SessionID, err)
	}

	plateNumber := strings.TrimSpace(req.PlateNumber)
	rfidTag := strings.TrimSpace(req.RFIDTag)
	if plateNumber == "" && rfidTag == "" {
		return nil, ErrSessionIdentifierEmpty
	}
	if plateNumber != "" && rfidTag != "" {
		if session, err := s.repo.FindActiveByExactIdentityTx(db, plateNumber, rfidTag); err == nil {
			return session, nil
		} else if !errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, err
		}
	}

	var plateSessions, rfidSessions []dao.VehicleRecord
	var err error
	if plateNumber != "" {
		plateSessions, err = s.repo.FindActiveByPlateTx(db, plateNumber)
		if err != nil {
			return nil, err
		}
	}
	if rfidTag != "" {
		rfidSessions, err = s.repo.FindActiveByRFIDTx(db, rfidTag)
		if err != nil {
			return nil, err
		}
	}

	if len(plateSessions) > 1 || len(rfidSessions) > 1 {
		return nil, ErrSessionAmbiguous
	}
	if len(plateSessions) == 1 && len(rfidSessions) == 1 && plateSessions[0].ID != rfidSessions[0].ID {
		return nil, ErrSessionIdentityConflict
	}
	if len(plateSessions) == 1 {
		return &plateSessions[0], nil
	}
	if len(rfidSessions) == 1 {
		return &rfidSessions[0], nil
	}
	return nil, ErrSessionNotFound
}

func sessionLookupError(db *gorm.DB, id uint, err error) error {
	if !errors.Is(err, gorm.ErrRecordNotFound) {
		return err
	}
	var session dao.VehicleRecord
	if lookupErr := db.Unscoped().First(&session, id).Error; lookupErr == nil {
		if session.ExitTime != nil {
			return ErrSessionAlreadyClosed
		}
		if session.PaymentStatus == PaymentStatusPaid {
			return ErrSessionAlreadyPaid
		}
		return ErrSessionNotFound
	} else if !errors.Is(lookupErr, gorm.ErrRecordNotFound) {
		return lookupErr
	}
	return ErrSessionNotFound
}

// OpenSessionTx creates a durable parking session. The active-session lookup
// is repeated in the caller transaction to make the validation part of the
// same atomic operation as the insert.
func (s *ParkingSessionService) OpenSessionTx(db *gorm.DB, req request.OpenSessionRequest) (*dao.VehicleRecord, error) {
	if db == nil {
		return nil, errors.New("数据库未初始化")
	}
	req.PlateNumber = strings.TrimSpace(req.PlateNumber)
	req.RFIDTag = strings.TrimSpace(req.RFIDTag)
	if req.PlateNumber == "" && req.RFIDTag == "" {
		return nil, ErrSessionIdentifierEmpty
	}

	_, err := s.ResolveActiveSessionTx(db, request.ResolveActiveSessionRequest{
		PlateNumber: req.PlateNumber,
		RFIDTag:     req.RFIDTag,
	})
	if err == nil {
		return nil, ErrSessionAlreadyOpen
	}
	if !errors.Is(err, ErrSessionNotFound) {
		return nil, err
	}

	entryTime := req.EntryTime
	if entryTime.IsZero() {
		entryTime = time.Now()
	}
	session := &dao.VehicleRecord{
		PlateNumber:    req.PlateNumber,
		RFIDTag:        req.RFIDTag,
		EntryTime:      entryTime,
		ParkingLotID:   req.ParkingLotID,
		ParkingSpaceID: req.ParkingSpaceID,
		EntryImage:     req.EntryImage,
		PaymentStatus:  PaymentStatusUnpaid,
	}
	if err := s.repo.CreateTx(db, session); err != nil {
		return nil, err
	}
	return session, nil
}

// MarkPaidTx updates the current settlement summary on a still-active session.
// The payment_record created by the payment module remains the source of truth
// for the monetary transaction itself.
func (s *ParkingSessionService) MarkPaidTx(db *gorm.DB, sessionID uint, paymentEntry, paymentMethod string, fee float64) (*dao.VehicleRecord, error) {
	if db == nil {
		return nil, errors.New("数据库未初始化")
	}
	if sessionID == 0 {
		return nil, ErrSessionNotFound
	}
	if math.IsNaN(fee) || math.IsInf(fee, 0) || fee < 0 {
		return nil, errors.New("停车费用必须是有限的非负数")
	}

	session, err := s.ResolveActiveSessionTx(db, request.ResolveActiveSessionRequest{SessionID: sessionID})
	if err != nil {
		return nil, err
	}
	if session.PaymentStatus == PaymentStatusPaid {
		return nil, ErrSessionAlreadyPaid
	}

	rows, err := s.repo.UpdateUnpaidActiveTx(db, sessionID, map[string]interface{}{
		"payment_status": PaymentStatusPaid,
		"payment_entry":  paymentEntry,
		"payment_method": paymentMethod,
		"fee":            fee,
	})
	if err != nil {
		return nil, fmt.Errorf("更新停车会话支付状态失败: %w", err)
	}
	if rows != 1 {
		return nil, sessionLookupError(db, sessionID, gorm.ErrRecordNotFound)
	}
	session.PaymentStatus = PaymentStatusPaid
	session.PaymentEntry = paymentEntry
	session.PaymentMethod = paymentMethod
	session.Fee = fee
	return session, nil
}

// CloseSessionTx finalizes one paid parking session exactly once.
func (s *ParkingSessionService) CloseSessionTx(db *gorm.DB, req request.CloseSessionRequest) (*dao.VehicleRecord, error) {
	if db == nil {
		return nil, errors.New("数据库未初始化")
	}
	if req.SessionID == 0 {
		return nil, ErrSessionNotFound
	}
	if req.StayTime < 0 || math.IsNaN(req.Fee) || math.IsInf(req.Fee, 0) || req.Fee < 0 {
		return nil, errors.New("停车会话结算数据无效")
	}

	session, err := s.ResolveActiveSessionTx(db, request.ResolveActiveSessionRequest{SessionID: req.SessionID})
	if err != nil {
		return nil, err
	}
	exitTime := req.ExitTime
	if exitTime.IsZero() {
		exitTime = time.Now()
	}
	paymentStatus := req.PaymentStatus
	if paymentStatus == "" {
		paymentStatus = PaymentStatusPaid
	}
	updates := map[string]interface{}{
		"exit_time":      exitTime,
		"stay_time":      req.StayTime,
		"fee":            req.Fee,
		"payment_status": paymentStatus,
		"payment_entry":  req.PaymentEntry,
		"payment_method": req.PaymentMethod,
	}
	if req.ExitImage != "" {
		updates["exit_image"] = req.ExitImage
	}
	rows, err := s.repo.UpdateActiveTx(db, req.SessionID, updates)
	if err != nil {
		return nil, fmt.Errorf("关闭停车会话失败: %w", err)
	}
	if rows != 1 {
		return nil, sessionLookupError(db, req.SessionID, gorm.ErrRecordNotFound)
	}
	session.ExitTime = &exitTime
	session.StayTime = req.StayTime
	session.Fee = req.Fee
	session.PaymentStatus = paymentStatus
	session.PaymentEntry = req.PaymentEntry
	session.PaymentMethod = req.PaymentMethod
	if req.ExitImage != "" {
		session.ExitImage = req.ExitImage
	}
	return session, nil
}