package vehicle

import (
	"wails-app/internal/dao"
	"wails-app/internal/global"
	"wails-app/internal/model/vehicle/request"
)

type VehicleRecordService struct{}

// GetVehicleRecordByID 根据ID获取车辆记录
func (s *VehicleRecordService) GetVehicleRecordByID(id uint) (dao.VehicleRecord, error) {
	var record dao.VehicleRecord
	result := global.GVA_DB.First(&record, id)
	if result.RowsAffected == 0 {
		return dao.VehicleRecord{}, result.Error
	}
	records := []dao.VehicleRecord{record}
	if err := hydratePassageNames(records); err != nil {
		return dao.VehicleRecord{}, err
	}
	return records[0], nil
}

// ListVehicleRecordsByPlateNumber 根据车牌号获取车辆记录列表
func (s *VehicleRecordService) ListVehicleRecordsByPlateNumber(plateNumber string, page, pageSize int) (int64, []dao.VehicleRecord, error) {
	var records []dao.VehicleRecord
	var total int64

	query := global.GVA_DB.Model(&dao.VehicleRecord{}).Where("plate_number = ?", plateNumber)

	// 计算总数
	query.Count(&total)

	// 分页查询
	offset := (page - 1) * pageSize
	result := query.Order("entry_time DESC").Offset(offset).Limit(pageSize).Find(&records)
	if result.Error != nil {
		return 0, nil, result.Error
	}
	if err := hydratePassageNames(records); err != nil {
		return 0, nil, err
	}

	return total, records, nil
}

// ListVehicleRecords 获取所有车辆记录列表
func (s *VehicleRecordService) ListVehicleRecords(info request.VehicleRecordRequest) (list []dao.VehicleRecord, total int64, err error) {
	db := global.GVA_DB.Model(&dao.VehicleRecord{})

	limit := info.PageSize
	offset := info.PageSize * (info.Page - 1)

	// 车牌号模糊查询
	if info.PlateNumber != "" {
		db = db.Where("plate_number LIKE ?", "%"+info.PlateNumber+"%")
	}

	// RFID标签精确查询
	if info.RFIDTag != "" {
		db = db.Where("rfid_tag LIKE ?", "%"+info.RFIDTag+"%")
	}

	// 查询总数
	err = db.Count(&total).Error
	if err != nil {
		return nil, 0, err
	}

	// 分页查询 + 排序
	err = db.Order("entry_time DESC").Limit(limit).Offset(offset).Find(&list).Error
	if err != nil {
		return nil, 0, err
	}
	if err := hydratePassageNames(list); err != nil {
		return nil, 0, err
	}
	return list, total, nil
}

func hydratePassageNames(records []dao.VehicleRecord) error {
	channelIDs := make([]uint, 0, len(records)*2)
	deviceCodes := make([]string, 0, len(records)*2)
	for _, record := range records {
		if record.EntryChannelName == "" && record.EntryChannelID != 0 {
			channelIDs = append(channelIDs, record.EntryChannelID)
		}
		if record.ExitChannelName == "" && record.ExitChannelID != 0 {
			channelIDs = append(channelIDs, record.ExitChannelID)
		}
		if record.EntryDeviceName == "" && record.EntryDeviceCode != "" {
			deviceCodes = append(deviceCodes, record.EntryDeviceCode)
		}
		if record.ExitDeviceName == "" && record.ExitDeviceCode != "" {
			deviceCodes = append(deviceCodes, record.ExitDeviceCode)
		}
	}

	channelNames := make(map[uint]string, len(channelIDs))
	if len(channelIDs) > 0 {
		var channels []dao.Channel
		if err := global.GVA_DB.Where("id IN ?", channelIDs).Find(&channels).Error; err != nil {
			return err
		}
		for _, channel := range channels {
			channelNames[channel.ID] = channel.ChannelName
		}
	}

	deviceNames := make(map[string]string, len(deviceCodes))
	if len(deviceCodes) > 0 {
		var devices []dao.UHFReader
		if err := global.GVA_DB.Where("device_code IN ?", deviceCodes).Find(&devices).Error; err != nil {
			return err
		}
		for _, device := range devices {
			deviceNames[device.DeviceCode] = device.DeviceName
		}
	}

	for i := range records {
		if records[i].EntryChannelName == "" {
			records[i].EntryChannelName = channelNames[records[i].EntryChannelID]
		}
		if records[i].ExitChannelName == "" {
			records[i].ExitChannelName = channelNames[records[i].ExitChannelID]
		}
		if records[i].EntryDeviceName == "" {
			records[i].EntryDeviceName = deviceNames[records[i].EntryDeviceCode]
		}
		if records[i].ExitDeviceName == "" {
			records[i].ExitDeviceName = deviceNames[records[i].ExitDeviceCode]
		}
	}
	return nil
}