package main

import (
	"fmt"
	"math/rand"
	"time"

	bubbletea "github.com/charmbracelet/bubbletea"
)

// Размер игрового поля.
const (
	boardWidth  = 15
	boardHeight = 15
)

// Возможные состояния приложения: меню выбора сложности, игра, конец игры.
type gameState int

const (
	stateMenu gameState = iota
	statePlaying
	stateGameOver
)

// Возможные направления движения змейки.
type direction int

const (
	dirUp direction = iota
	dirDown
	dirLeft
	dirRight
)

// Сложность и соответствующие интервалы тиков.
var (
	difficulties = []string{"Низкая", "Средняя", "Высокая"}
	speeds       = []time.Duration{
		300 * time.Millisecond, // Низкая
		150 * time.Millisecond, // Средняя
		75 * time.Millisecond,  // Высокая
	}
)

// Сообщения, используемые в Update.
type tickMsg time.Time
type gameOverMsg struct{}
type restartMsg struct{}

// Позиция на поле.
type position struct {
	x int
	y int
}

// Модель приложения.
type model struct {
	state gameState

	// --- Меню ---
	menuChoice int // Индекс выбранной сложности

	// --- Игра ---
	snake      []position // Срез координат змейки
	direction  direction  // Текущее направление движения
	food       position   // Позиция еды
	score      int        // Количество съеденной еды
	speed      time.Duration
	randSource rand.Source // Для генерации случайных позиций еды
}

// Обязательный метод Init() для реализации интерфейса bubbletea.Model.
func (m model) Init() bubbletea.Cmd {
	// На старте ничего не делаем. Можно вернуть nil.
	return nil
}

// Инициализация модели (начальное состояние).
func initialModel() model {
	m := model{
		state:      stateMenu,
		menuChoice: 0,
	}
	return m
}

// Команда тика, чтобы игра обновлялась через определённые промежутки.
func tickCmd(d time.Duration) bubbletea.Cmd {
	return bubbletea.Tick(d, func(t time.Time) bubbletea.Msg {
		return tickMsg(t)
	})
}

// Инициализация новой игры (при переходе из меню или рестарте).
func (m *model) initGame() {
	// Сразу зададим начальное направление — вправо.
	m.direction = dirRight
	m.score = 0

	// Пусть начальная длина змейки = 1, позиционируем змею в центре.
	startPos := position{
		x: boardWidth / 2,
		y: boardHeight / 2,
	}
	m.snake = []position{startPos}

	// Генератор случайных чисел.
	m.randSource = rand.NewSource(time.Now().UnixNano())

	// Сгенерировать еду в случайном месте.
	m.generateFood()
}

// Генерация еды в новом месте, где нет змейки.
func (m *model) generateFood() {
	rnd := rand.New(m.randSource)
	for {
		foodPos := position{
			x: rnd.Intn(boardWidth),
			y: rnd.Intn(boardHeight),
		}
		// Проверим, чтобы еда не попадала на змею.
		if !m.containsSnake(foodPos) {
			m.food = foodPos
			return
		}
	}
}

// Проверка, содержится ли позиция внутри змейки.
func (m *model) containsSnake(pos position) bool {
	for _, s := range m.snake {
		if s.x == pos.x && s.y == pos.y {
			return true
		}
	}
	return false
}

// Логика обновления модели по сообщениям.
func (m model) Update(msg bubbletea.Msg) (bubbletea.Model, bubbletea.Cmd) {
	switch m.state {
	// ------------------------------------------------
	// Меню выбора сложности
	// ------------------------------------------------
	case stateMenu:
		switch msg := msg.(type) {
		case bubbletea.KeyMsg:
			switch msg.String() {
			case "up":
				if m.menuChoice > 0 {
					m.menuChoice--
				}
			case "down":
				if m.menuChoice < len(difficulties)-1 {
					m.menuChoice++
				}
			case "enter":
				// Устанавливаем скорость в зависимости от выбранной сложности.
				m.speed = speeds[m.menuChoice]
				m.initGame()
				m.state = statePlaying
				// Запускаем тики.
				return m, tickCmd(m.speed)
			case "q", "esc":
				// Выход из игры.
				return m, bubbletea.Quit
			}
		}
		return m, nil

	// ------------------------------------------------
	// Игровое состояние
	// ------------------------------------------------
	case statePlaying:
		switch msg := msg.(type) {
		// Каждый тик — сдвиг змейки
		case tickMsg:
			m = m.moveSnake()
			// Если после движения мы в состоянии Game Over, значит столкнулись.
			if m.state == stateGameOver {
				return m, nil
			}
			// Иначе продолжаем тики.
			return m, tickCmd(m.speed)

		case bubbletea.KeyMsg:
			switch msg.String() {
			case "up":
				if m.direction != dirDown { // Чтобы избежать разворота на 180
					m.direction = dirUp
				}
			case "down":
				if m.direction != dirUp {
					m.direction = dirDown
				}
			case "left":
				if m.direction != dirRight {
					m.direction = dirLeft
				}
			case "right":
				if m.direction != dirLeft {
					m.direction = dirRight
				}
			case "q", "esc":
				// Выход из игры.
				return m, bubbletea.Quit
			}
		}
		return m, nil

	// ------------------------------------------------
	// Состояние конца игры
	// ------------------------------------------------
	case stateGameOver:
		switch msg := msg.(type) {
		case bubbletea.KeyMsg:
			switch msg.String() {
			case "r":
				// Перезапуск: возвращаемся в меню.
				m.state = stateMenu
				m.menuChoice = 0
				return m, nil
			case "q", "esc":
				return m, bubbletea.Quit
			}
		}
		return m, nil
	}

	return m, nil
}

// Функция перемещения змейки.
func (m model) moveSnake() model {
	head := m.snake[len(m.snake)-1]
	newHead := head

	// Определяем новый заголовок (координаты головы) по направлению.
	switch m.direction {
	case dirUp:
		newHead.y--
	case dirDown:
		newHead.y++
	case dirLeft:
		newHead.x--
	case dirRight:
		newHead.x++
	}

	// Проверяем выход за границы — конец игры.
	if newHead.x < 0 || newHead.x >= boardWidth ||
		newHead.y < 0 || newHead.y >= boardHeight {
		m.state = stateGameOver
		return m
	}

	// Проверяем столкновение с самим собой.
	if m.containsSnake(newHead) {
		m.state = stateGameOver
		return m
	}

	// Если попали на еду.
	if newHead.x == m.food.x && newHead.y == m.food.y {
		// Увеличиваем счёт.
		m.score++
		// Добавляем новую голову, хвост не удаляем (змейка растёт).
		m.snake = append(m.snake, newHead)
		// Генерируем новую еду.
		m.generateFood()
	} else {
		// Сдвигаем хвост и добавляем новую голову.
		m.snake = append(m.snake[1:], newHead)
	}

	return m
}

// Отрисовка меню, игрового поля и экрана конца игры.
func (m model) View() string {
	switch m.state {
	case stateMenu:
		return m.viewMenu()
	case statePlaying:
		return m.viewGame()
	case stateGameOver:
		return m.viewGameOver()
	default:
		return ""
	}
}

// Отображение меню выбора сложности.
func (m model) viewMenu() string {
	s := "Выберите сложность:\n\n"
	for i, diff := range difficulties {
		cursor := "  "
		if i == m.menuChoice {
			cursor = "> "
		}
		s += fmt.Sprintf("%s%s\n", cursor, diff)
	}
	s += "\n↑/↓ - выбор, Enter - подтвердить, q/esc - выход\n"
	return s
}

// Отображение игрового поля.
func (m model) viewGame() string {
	var view string

	// Счёт.
	view += fmt.Sprintf("Счёт: %d\n\n", m.score)

	// Создадим карту для быстрой проверки: где находится змейка?
	snakePositions := make(map[position]bool)
	for _, pos := range m.snake {
		snakePositions[pos] = true
	}

	// Рисуем сетку 15x15.
	for y := 0; y < boardHeight; y++ {
		for x := 0; x < boardWidth; x++ {
			switch {
			case x == m.food.x && y == m.food.y:
				// Красная еда
				view += "\033[31m*\033[0m"
			case snakePositions[position{x, y}]:
				// Змейка (зелёная)
				view += "\033[32mO\033[0m"
			default:
				view += " "
			}
		}
		view += "\n"
	}

	view += "\nНажмите q/esc для выхода.\n"
	return view
}

// Отображение экрана конца игры.
func (m model) viewGameOver() string {
	s := fmt.Sprintf("Игра окончена! Ваш счёт: %d\n", m.score)
	s += "Нажмите r для возврата в меню или q/esc для выхода.\n"
	return s
}

func main() {
	rand.Seed(time.Now().UnixNano())
	p := bubbletea.NewProgram(initialModel())
	if err := p.Start(); err != nil {
		fmt.Println("Ошибка запуска программы:", err)
	}
}

package main

import (
	"fmt"
	"math/rand"
	"os"
	"time"

	bubbletea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
	"golang.org/x/term"
)

const (
	width  = 15
	height = 15
	border = 1
)

type direction int

const (
	up direction = iota
	down
	left
	right
)

type difficulty int

const (
	low difficulty = iota
	medium
	high
)

type model struct {
	snake      []position
	food       position
	dir        direction
	nextDir    direction
	score      int
	gameOver   bool
	difficulty difficulty
	chosenDiff bool
}

type position struct {
	x, y int
}

type tickMsg time.Time

var (
	snakeStyle  = lipgloss.NewStyle().Foreground(lipgloss.Color("10"))
	foodStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color("9"))
	borderStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("8"))
	scoreStyle  = lipgloss.NewStyle().Bold(true)
)

func initialModel() model {
	return model{
		snake: []position{{x: width/2 + border, y: height/2 + border}},
		dir:   right,
	}
}

func (m model) Init() bubbletea.Cmd {
	return tick()
}

func tick() bubbletea.Cmd {
	return bubbletea.Tick(time.Second, func(t time.Time) bubbletea.Msg {
		return tickMsg(t)
	})
}

func (m model) Update(msg bubbletea.Msg) (bubbletea.Model, bubbletea.Cmd) {
	if !m.chosenDiff {
		switch msg := msg.(type) {
		case bubbletea.KeyMsg:
			switch msg.String() {
			case "1":
				m.difficulty = low
				m.chosenDiff = true
			case "2":
				m.difficulty = medium
				m.chosenDiff = true
			case "3":
				m.difficulty = high
				m.chosenDiff = true
			case "q", "ctrl+c":
				os.Exit(0)
			}
		}
		if m.chosenDiff {
			m.placeFood()
			return m, bubbletea.Tick(getInterval(m.difficulty), func(t time.Time) bubbletea.Msg {
				return tickMsg(t)
			})
		}
		return m, nil
	}

	if m.gameOver {
		if key, ok := msg.(bubbletea.KeyMsg); ok {
			if key.String() == "q" || key.String() == "ctrl+c" {
				os.Exit(0)
			}
		}
		return m, nil
	}

	switch msg := msg.(type) {
	case bubbletea.KeyMsg:
		switch msg.String() {
		case "up":
			if m.dir != down {
				m.nextDir = up
			}
		case "down":
			if m.dir != up {
				m.nextDir = down
			}
		case "left":
			if m.dir != right {
				m.nextDir = left
			}
		case "right":
			if m.dir != left {
				m.nextDir = right
			}
		case "q", "ctrl+c":
			os.Exit(0)
		}

	case tickMsg:
		m.dir = m.nextDir
		head := m.snake[0]
		newHead := head

		switch m.dir {
		case up:
			newHead.y--
		case down:
			newHead.y++
		case left:
			newHead.x--
		case right:
			newHead.x++
		}

		if newHead.x <= border || newHead.x >= width+border ||
			newHead.y <= border || newHead.y >= height+border ||
			m.collidesWithSnake(newHead) {
			m.gameOver = true
			return m, nil
		}

		m.snake = append([]position{newHead}, m.snake...)

		if newHead == m.food {
			m.score++
			m.placeFood()
		} else {
			m.snake = m.snake[:len(m.snake)-1]
		}

		return m, bubbletea.Tick(getInterval(m.difficulty), func(t time.Time) bubbletea.Msg {
			return tickMsg(t)
		})
	}

	return m, nil
}

func (m *model) placeFood() {
	for {
		m.food = position{
			x: rand.Intn(width) + border + 1,
			y: rand.Intn(height) + border + 1,
		}
		if !m.collidesWithSnake(m.food) {
			break
		}
	}
}

func (m model) collidesWithSnake(p position) bool {
	for _, segment := range m.snake {
		if segment == p {
			return true
		}
	}
	return false
}

func getInterval(d difficulty) time.Duration {
	switch d {
	case low:
		return 200 * time.Millisecond
	case medium:
		return 100 * time.Millisecond
	case high:
		return 50 * time.Millisecond
	default:
		return 100 * time.Millisecond
	}
}

func (m model) View() string {
	if !m.chosenDiff {
		return "Choose difficulty:\n1. Low\n2. Medium\n3. High\n\nPress q to quit"
	}

	if m.gameOver {
		return fmt.Sprintf("Game Over! Score: %d\nPress q to quit", m.score)
	}

	physicalWidth, physicalHeight, _ := term.GetSize(int(os.Stdout.Fd()))
	field := m.drawField()
	score := scoreStyle.Render(fmt.Sprintf("Score: %d", m.score))

	return lipgloss.Place(
		physicalWidth,
		physicalHeight,
		lipgloss.Center,
		lipgloss.Center,
		lipgloss.JoinVertical(lipgloss.Center, field, score),
	)
}

func (m model) drawField() string {
	field := ""
	for y := 0; y < height+border*2+1; y++ {
		for x := 0; x < width+border*2+1; x++ {
			switch {
			case x == border || x == width+border || y == border || y == height+border:
				field += borderStyle.Render("#")
			case x == m.food.x && y == m.food.y:
				field += foodStyle.Render("●")
			default:
				isSnake := false
				for i, p := range m.snake {
					if p.x == x && p.y == y {
						isSnake = true
						if i == 0 {
							field += snakeStyle.Render("●")
						} else {
							field += snakeStyle.Render("○")
						}
						break
					}
				}
				if !isSnake {
					field += " "
				}
			}
		}
		field += "\n"
	}
	return field
}

func main() {
	rand.Seed(time.Now().UnixNano())
	p := bubbletea.NewProgram(initialModel(), bubbletea.WithAltScreen())
	if err := p.Start(); err != nil {
		fmt.Println("Error running program:", err)
		os.Exit(1)
	}
}

package main

import (
	"fmt"
	"sync"
	"time"
)

// Priority определяет приоритет задачи.
type Priority int

const (
	LowPriority Priority = iota
	HighPriority
)

// Task описывает задачу для выполнения.
type Task struct {
	Priority Priority
	Job      func()
}

// WorkerPool управляет пулам воркеров с приоритетом задач.
type WorkerPool struct {
	highPriorityCh chan Task
	lowPriorityCh  chan Task

	// Количество воркеров
	workerCount int

	// Канал для сигнализации остановки
	stopCh chan struct{}

	// wgHigh отслеживает только задачи с высоким приоритетом
	wgHigh sync.WaitGroup

	// wgAll отслеживает все задачи (если захотите дождаться вообще всех)
	wgAll sync.WaitGroup

	// Один раз закрываем stopCh
	once sync.Once
}

// NewWorkerPool создаёт новый пул воркеров.
//   - workerCount: количество воркеров
//   - queueSize: размер каналов для задач
func NewWorkerPool(workerCount, queueSize int) *WorkerPool {
	return &WorkerPool{
		highPriorityCh: make(chan Task, queueSize),
		lowPriorityCh:  make(chan Task, queueSize),
		workerCount:    workerCount,
		stopCh:         make(chan struct{}),
	}
}

// Start запускает заданное количество горутин-воркеров.
func (p *WorkerPool) Start() {
	for i := 0; i < p.workerCount; i++ {
		go p.worker()
	}
}

// Submit добавляет задачу в очередь соответствующего приоритета.
// Если каналы заполнены, вызов будет блокироваться до освобождения места.
func (p *WorkerPool) Submit(task Task) {
	// Увеличиваем счетчики в зависимости от приоритета
	p.wgAll.Add(1)
	if task.Priority == HighPriority {
		p.wgHigh.Add(1)
	}

	// Отправляем задачу в нужный канал
	switch task.Priority {
	case HighPriority:
		p.highPriorityCh <- task
	case LowPriority:
		p.lowPriorityCh <- task
	}
}

// Stop останавливает пул воркеров:
//   1. Дожидаемся выполнения всех задач с высоким приоритетом.
//   2. Закрываем канал stopCh, чтобы сигнализировать воркерам завершение работы.
// Обратите внимание: если вам нужно дождаться всех задач (включая LowPriority),
// то дополнительно вызовите p.wgAll.Wait().
func (p *WorkerPool) Stop() {
	// Сначала дожидаемся выполнения всех высокоприоритетных задач
	p.wgHigh.Wait()

	// Сигнализируем горутинам, что пора завершаться
	p.once.Do(func() {
		close(p.stopCh)
	})

	// Если хотите гарантировать завершение ВСЕХ задач, то раскомментируйте:
	// p.wgAll.Wait()
}

// собственно worker-функция, которую исполняют горутины
func (p *WorkerPool) worker() {
	for {
		select {
		case <-p.stopCh:
			// Как только получили сигнал остановки – выходим
			return
		default:
		}

		// Сначала пытаемся взять задачу из highPriorityCh (если там что-то есть)
		select {
		case task := <-p.highPriorityCh:
			p.execute(task)
		default:
			// Если в highPriorityCh нет задач, берём из lowPriorityCh
			select {
			case task := <-p.lowPriorityCh:
				p.execute(task)
			case <-p.stopCh:
				return
			}
		}
	}
}

// execute выполняет переданную задачу и корректно обновляет счётчики.
func (p *WorkerPool) execute(task Task) {
	defer func() {
		// По завершении задачи уменьшаем оба счётчика (при необходимости)
		p.wgAll.Done()
		if task.Priority == HighPriority {
			p.wgHigh.Done()
		}
	}()
	// Собственно выполнение задачи
	task.Job()
}

// Пример использования
func main() {
	// Создаём пул с 3 воркерами и размером каналов 10
	pool := NewWorkerPool(3, 10)

	// Запускаем воркеров
	pool.Start()

	for i := 0; i < 5; i++ {
		// Задачи с низким приоритетом
		pool.Submit(Task{
			Priority: LowPriority,
			Job: func() {
				fmt.Println("Low priority task started")
				time.Sleep(time.Millisecond * 500)
				fmt.Println("Low priority task finished")
			},
		})
	}

	// Публикуем несколько задач в пул
	for i := 0; i < 5; i++ {
		// Задачи с высоким приоритетом
		pool.Submit(Task{
			Priority: HighPriority,
			Job: func() {
				fmt.Println("High priority task started")
				time.Sleep(time.Millisecond * 200)
				fmt.Println("High priority task finished")
			},
		})
	}

	// Останавливаем пул. Гарантируется, что все HighPriority-задачи закончатся.
	pool.Stop()

	// Если нужно дождаться завершения всех задач, раскомментируйте:
	// pool.wgAll.Wait()

	fmt.Println("Main finished")
}

package main

import (
	"errors"
	"fmt"
	"sync"
	"time"
)

type Priority int

const (
	HighPriority Priority = iota
	LowPriority
)

type Task struct {
	Priority Priority
	Job      func()
}

type WorkerPool struct {
	highChan chan Task
	lowChan  chan Task
	highWg   sync.WaitGroup
	lowWg    sync.WaitGroup
	quit     chan struct{}
	once     sync.Once
}

func NewWorkerPool(numWorkers, highChanSize, lowChanSize int) *WorkerPool {
	wp := &WorkerPool{
		highChan: make(chan Task, highChanSize),
		lowChan:  make(chan Task, lowChanSize),
		quit:     make(chan struct{}),
	}

	for i := 0; i < numWorkers; i++ {
		go wp.worker()
	}

	return wp
}

func (wp *WorkerPool) Submit(task Task) error {
	select {
	case <-wp.quit:
		return errors.New("worker pool is stopped")
	default:
	}

	switch task.Priority {
	case HighPriority:
		select {
		case wp.highChan <- task:
			wp.highWg.Add(1)
		default:
			return errors.New("high priority queue is full")
		}
	case LowPriority:
		select {
		case wp.lowChan <- task:
			wp.lowWg.Add(1)
		default:
			return errors.New("low priority queue is full")
		}
	default:
		return errors.New("invalid task priority")
	}

	return nil
}

func (wp *WorkerPool) Stop() {
	wp.once.Do(func() {
		close(wp.quit)
		close(wp.highChan)
		close(wp.lowChan)
		wp.highWg.Wait()
		wp.lowWg.Wait()
	})
}

func (wp *WorkerPool) worker() {
	defer func() {
		// Process remaining high priority tasks first
		for task := range wp.highChan {
			task.Job()
			wp.highWg.Done()
		}
		// Then process low priority tasks
		for task := range wp.lowChan {
			task.Job()
			wp.lowWg.Done()
		}
	}()

	for {
		select {
		case <-wp.quit:
			return
		default:
		}

		select {
		case task, ok := <-wp.highChan:
			if !ok {
				return
			}
			task.Job()
			wp.highWg.Done()
		default:
			select {
			case task, ok := <-wp.highChan:
				if !ok {
					return
				}
				task.Job()
				wp.highWg.Done()
			case task, ok := <-wp.lowChan:
				if !ok {
					return
				}
				task.Job()
				wp.lowWg.Done()
			}
		}
	}
}

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"strings"
	"sync"
)

// Task — наша сущность "Задача".
type Task struct {
	ID          string `json:"id"`
	Title       string `json:"title"`
	Description string `json:"description"`
}

// tasksMap — хранилище наших задач в памяти.
var tasksMap = make(map[string]Task)

// mutex — простой мьютекс для безопасного доступа к карте из нескольких горутин.
var mutex = &sync.Mutex{}

func main() {
	http.HandleFunc("/api/v1/task/", taskHandler)
	http.HandleFunc("/api/v1/task", taskHandler)

	fmt.Println("Сервер запущен на порту 8080...")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

// taskHandler обрабатывает все CRUD-операции над задачами.
func taskHandler(w http.ResponseWriter, r *http.Request) {
	// Отключаем кэширование и устанавливаем тип контента как JSON.
	w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
	w.Header().Set("Content-Type", "application/json; charset=utf-8")

	// Определяем, есть ли в пути ID задачи (например, /api/v1/task/123).
	// Если путь заканчивается на /api/v1/task/, значит ID либо отсутствует, либо пустой.
	id := strings.TrimPrefix(r.URL.Path, "/api/v1/task/")
	id = strings.Trim(id, "/")

	switch r.Method {
	case http.MethodGet:
		if id == "" {
			getAllTasks(w, r)
		} else {
			getTaskByID(w, r, id)
		}
	case http.MethodPost:
		createTask(w, r)
	case http.MethodPut:
		updateTask(w, r, id)
	case http.MethodDelete:
		deleteTask(w, r, id)
	default:
		http.Error(w, "Метод не поддерживается", http.StatusMethodNotAllowed)
	}
}

// getAllTasks возвращает список всех задач.
func getAllTasks(w http.ResponseWriter, r *http.Request) {
	mutex.Lock()
	defer mutex.Unlock()

	var tasks []Task
	for _, task := range tasksMap {
		tasks = append(tasks, task)
	}

	jsonData, err := json.Marshal(tasks)
	if err != nil {
		http.Error(w, "Ошибка при сериализации JSON", http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusOK)
	w.Write(jsonData)
}

// getTaskByID возвращает задачу по её ID.
func getTaskByID(w http.ResponseWriter, r *http.Request, id string) {
	mutex.Lock()
	defer mutex.Unlock()

	task, exists := tasksMap[id]
	if !exists {
		http.Error(w, "Задача не найдена", http.StatusNotFound)
		return
	}

	jsonData, err := json.Marshal(task)
	if err != nil {
		http.Error(w, "Ошибка при сериализации JSON", http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusOK)
	w.Write(jsonData)
}

// createTask создаёт новую задачу.
func createTask(w http.ResponseWriter, r *http.Request) {
	var t Task

	// Декодируем JSON из тела запроса.
	if err := json.NewDecoder(r.Body).Decode(&t); err != nil {
		http.Error(w, "Некорректный JSON", http.StatusBadRequest)
		return
	}

	// Проверяем, что передан непустой ID (для упрощения).
	if t.ID == "" {
		http.Error(w, "Поле 'id' не должно быть пустым", http.StatusBadRequest)
		return
	}

	mutex.Lock()
	defer mutex.Unlock()

	// Проверяем, нет ли уже задачи с таким ID.
	if _, exists := tasksMap[t.ID]; exists {
		http.Error(w, "Задача с таким ID уже существует", http.StatusConflict)
		return
	}

	// Сохраняем задачу в карту.
	tasksMap[t.ID] = t

	// Возвращаем созданный объект.
	jsonData, err := json.Marshal(t)
	if err != nil {
		http.Error(w, "Ошибка при сериализации JSON", http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusCreated)
	w.Write(jsonData)
}

// updateTask обновляет задачу с указанным ID.
func updateTask(w http.ResponseWriter, r *http.Request, id string) {
	if id == "" {
		http.Error(w, "Не указан ID задачи", http.StatusBadRequest)
		return
	}

	var t Task
	if err := json.NewDecoder(r.Body).Decode(&t); err != nil {
		http.Error(w, "Некорректный JSON", http.StatusBadRequest)
		return
	}

	mutex.Lock()
	defer mutex.Unlock()

	_, exists := tasksMap[id]
	if !exists {
		http.Error(w, "Задача не найдена", http.StatusNotFound)
		return
	}

	// Обновляем данные задачи (предполагается, что ID не меняется).
	t.ID = id
	tasksMap[id] = t

	jsonData, err := json.Marshal(t)
	if err != nil {
		http.Error(w, "Ошибка при сериализации JSON", http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusOK)
	w.Write(jsonData)
}

// deleteTask удаляет задачу по её ID.
func deleteTask(w http.ResponseWriter, r *http.Request, id string) {
	if id == "" {
		http.Error(w, "Не указан ID задачи", http.StatusBadRequest)
		return
	}

	mutex.Lock()
	defer mutex.Unlock()

	_, exists := tasksMap[id]
	if !exists {
		http.Error(w, "Задача не найдена", http.StatusNotFound)
		return
	}

	delete(tasksMap, id)
	w.WriteHeader(http.StatusNoContent)
}

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"
	"strings"
	"sync"
	"time"
)

type Task struct {
	ID        int       `json:"id"`
	Title     string    `json:"title"`
	Completed bool      `json:"completed"`
	CreatedAt time.Time `json:"created_at"`
}

type TaskStore struct {
	sync.RWMutex
	tasks  map[int]Task
	nextID int
}

func (ts *TaskStore) CreateTask(title string) Task {
	ts.Lock()
	defer ts.Unlock()

	task := Task{
		ID:        ts.nextID,
		Title:     title,
		CreatedAt: time.Now(),
	}
	ts.tasks[ts.nextID] = task
	ts.nextID++
	return task
}

func (ts *TaskStore) GetTask(id int) (Task, bool) {
	ts.RLock()
	defer ts.RUnlock()

	task, exists := ts.tasks[id]
	return task, exists
}

func (ts *TaskStore) GetAllTasks() []Task {
	ts.RLock()
	defer ts.RUnlock()

	var tasks []Task
	for _, task := range ts.tasks {
		tasks = append(tasks, task)
	}
	return tasks
}

func (ts *TaskStore) UpdateTask(id int, title string, completed bool) (Task, bool) {
	ts.Lock()
	defer ts.Unlock()

	task, exists := ts.tasks[id]
	if !exists {
		return Task{}, false
	}

	task.Title = title
	task.Completed = completed
	ts.tasks[id] = task
	return task, true
}

func (ts *TaskStore) DeleteTask(id int) bool {
	ts.Lock()
	defer ts.Unlock()

	_, exists := ts.tasks[id]
	if !exists {
		return false
	}

	delete(ts.tasks, id)
	return true
}

type TaskServer struct {
	store *TaskStore
}

func (ts *TaskServer) handleTasks(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case "GET":
		tasks := ts.store.GetAllTasks()
		respondWithJSON(w, http.StatusOK, tasks)
	case "POST":
		var request struct {
			Title string `json:"title"`
		}
		if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
			http.Error(w, "Invalid request body", http.StatusBadRequest)
			return
		}

		task := ts.store.CreateTask(request.Title)
		respondWithJSON(w, http.StatusCreated, task)
	default:
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
	}
}

func (ts *TaskServer) handleSingleTask(w http.ResponseWriter, r *http.Request) {
	idStr := strings.TrimPrefix(r.URL.Path, "/api/v1/task/")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		http.Error(w, "Invalid task ID", http.StatusBadRequest)
		return
	}

	switch r.Method {
	case "GET":
		task, exists := ts.store.GetTask(id)
		if !exists {
			http.NotFound(w, r)
			return
		}
		respondWithJSON(w, http.StatusOK, task)
	case "PUT":
		var request struct {
			Title     string `json:"title"`
			Completed bool   `json:"completed"`
		}
		if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
			http.Error(w, "Invalid request body", http.StatusBadRequest)
			return
		}

		task, updated := ts.store.UpdateTask(id, request.Title, request.Completed)
		if !updated {
			http.NotFound(w, r)
			return
		}
		respondWithJSON(w, http.StatusOK, task)
	case "DELETE":
		deleted := ts.store.DeleteTask(id)
		if !deleted {
			http.NotFound(w, r)
			return
		}
		w.WriteHeader(http.StatusNoContent)
	default:
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
	}
}

func respondWithJSON(w http.ResponseWriter, status int, data interface{}) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	if err := json.NewEncoder(w).Encode(data); err != nil {
		http.Error(w, "Failed to encode response", http.StatusInternalServerError)
	}
}

func main() {
	store := &TaskStore{
		tasks:  make(map[int]Task),
		nextID: 1,
	}
	server := &TaskServer{store: store}

	mux := http.NewServeMux()
	mux.HandleFunc("/api/v1/task", server.handleTasks)
	mux.HandleFunc("/api/v1/task/", server.handleSingleTask)

	fmt.Println("Server is running on http://localhost:8080")
	http.ListenAndServe(":8080", mux)
}