package service

import (
	"sync"
	"time"
)

// Лимит устройств выдерживает ПАРАЛЛЕЛЬНЫЕ запросы авторизации.
//
// Что было. Проверка выглядела так:
//
//	onlineUsers, err := hysteria2Online()
//	if device, exist := onlineUsers[authID]; exist && maxDevices <= device {
//	    return deny
//	}
//	return allow
//
// Между чтением `/online` и ответом «allow» нет ничего, что удержало бы место,
// поэтому при одновременных подключениях выходило:
//
//	A: GET /online -> 2      B: GET /online -> 2
//	                 max = 3
//	A: 2 < 3 -> allow        B: 2 < 3 -> allow
//	                 стало 4
//
// Объявленный в панели «Лимит устройств: 3» превышался ровно тем способом,
// от которого лимит и должен защищать.
//
// Обычный мьютекс вокруг `/online` проблему не решает, и это главное, что
// нужно понимать про этот файл. Ответив «allow», админка не создаёт
// подключение — его только начинает устанавливать Hysteria, и в статистику
// клиент попадает позже. Следующий `/online`, даже строго после первого,
// продолжает показывать прежнее число. Сериализация запросов лишь сузила бы
// окно, оставив дефект на месте.
//
// Поэтому админка ведёт собственный учёт уже выданных, но ещё не проявившихся
// разрешений. HY2XS — один процесс на одном сервере с Hysteria, поэтому учёт
// process-local: ни Redis, ни таблицы в базе, ни распределённых блокировок для
// этого не нужно.
//
// Чего этот механизм НЕ обещает. Без обратного вызова от Hysteria
// «соединение установлено / не установлено» математически точной системы
// резервирования не построить. Он закрывает конкретный и реальный TOCTOU —
// параллельные HTTP-auth одного процесса, — и делает это fail-closed.

// pendingAdmissionTTL — срок жизни выданного разрешения, которое ещё не
// проявилось в `/online`.
//
// Величина внутренняя и пользовательской настройкой не является намеренно: это
// не политика доступа, а компенсация задержки между ответом авторизации и
// появлением клиента в статистике Hysteria. Настройка, смысл которой оператор
// не может оценить, порождает только неверные значения.
//
// Тридцать секунд — с большим запасом относительно установления QUIC-сессии и
// при этом заметно меньше, чем интервал, на котором оператор вообще заметил бы
// занятый слот. Если клиент авторизовался, но так и не подключился, резервация
// исчезает сама.
const pendingAdmissionTTL = 30 * time.Second

// admissionState — учёт по одному пиру.
type admissionState struct {
	// lastOnline — число устройств, показанное Traffic Stats API в прошлый
	// раз. Нужно, чтобы отличить рост (клиент подключился, резервация
	// проявилась) от неизменного значения.
	lastOnline int64
	// pending — сроки годности выданных, но ещё не проявившихся разрешений.
	// Хранится по одному значению на разрешение, а не счётчиком: иначе
	// протухать они могли бы только все разом.
	pending []time.Time
}

var deviceAdmissions = struct {
	sync.Mutex
	byAuthID map[string]*admissionState
}{byAuthID: map[string]*admissionState{}}

// reserveDeviceSlot решает, есть ли для нового подключения свободное место, и
// занимает его.
//
// Возвращает true, если подключение можно разрешить.
//
// Сетевой запрос к `/online` выполняется ВНЕ этого мьютекса — вызывающий
// передаёт сюда уже полученное число. Под блокировкой остаются только
// несколько операций с map: держать её на время HTTP-обмена значило бы
// сериализовать все подключения всех пиров через один сетевой запрос.
func reserveDeviceSlot(authID string, online int64, maxDevices int64, now time.Time) bool {
	deviceAdmissions.Lock()
	defer deviceAdmissions.Unlock()

	state := deviceAdmissions.byAuthID[authID]
	if state == nil {
		state = &admissionState{}
		deviceAdmissions.byAuthID[authID] = state
	}

	// 1. Протухшие разрешения освобождают место: клиент, который авторизовался
	//    и не подключился, не должен занимать слот вечно.
	state.dropExpired(now)

	// 2. Рост числа онлайн-устройств означает, что ровно столько выданных
	//    разрешений уже превратились в подключения. Не сняв их, админка
	//    посчитала бы одно и то же устройство дважды — сначала как резервацию,
	//    потом как реальное подключение, — и лимит стал бы вдвое строже
	//    объявленного.
	if online > state.lastOnline {
		state.dropMaterialized(online - state.lastOnline)
	}
	state.lastOnline = online

	// 3. Решение принимается по сумме: подтверждённые подключения плюс ещё не
	//    проявившиеся разрешения.
	if online+int64(len(state.pending)) >= maxDevices {
		// Место не занято и запись может оказаться ненужной: убираем её, чтобы
		// карта не росла от одних отказов.
		state.forgetIfIdle(authID)
		return false
	}

	state.pending = append(state.pending, now.Add(pendingAdmissionTTL))
	return true
}

// Функции «вернуть занятое место» здесь нет намеренно. После выдачи разрешения
// в Hysteria2Auth не остаётся ни одного шага, способного отказать, а
// controller.Hysteria2Auth на успешном ответе только обновляет
// last_connection_at и неудачу этого обновления считает несущественной.
// Освобождение, у которого нет вызывающего, было бы вторым способом менять
// состояние трекера — и первым кандидатом разойтись с reserveDeviceSlot.
// Разрешение, за которым не последовало подключения, снимает TTL.

func (s *admissionState) dropExpired(now time.Time) {
	kept := s.pending[:0]
	for _, deadline := range s.pending {
		if deadline.After(now) {
			kept = append(kept, deadline)
		}
	}
	s.pending = kept
}

// dropMaterialized снимает count самых старых разрешений: раньше выдано —
// раньше подключилось.
func (s *admissionState) dropMaterialized(count int64) {
	if count >= int64(len(s.pending)) {
		s.pending = s.pending[:0]
		return
	}
	s.pending = s.pending[count:]
}

// forgetIfIdle убирает запись, о которой больше нечего помнить.
//
// Без этого карта росла бы по одной записи на каждый когда-либо
// авторизовавшийся authId и не уменьшалась бы никогда — включая записи
// давно удалённых пиров.
func (s *admissionState) forgetIfIdle(authID string) {
	if len(s.pending) == 0 && s.lastOnline == 0 {
		delete(deviceAdmissions.byAuthID, authID)
	}
}

// resetDeviceAdmissions очищает учёт. Существует ради тестов: состояние здесь
// принадлежит процессу, и без сброса тесты видели бы резервации друг друга.
func resetDeviceAdmissions() {
	deviceAdmissions.Lock()
	defer deviceAdmissions.Unlock()
	deviceAdmissions.byAuthID = map[string]*admissionState{}
}