package app

import (
	"context"

	"evening_detective_server/internal/modules/roles"
	proto "evening_detective_server/proto"

	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

func canManagePlaylists(ctx context.Context) bool {
	claims, err := claimsFromContext(ctx)
	return err == nil && claims != nil &&
		(roles.HasRole(claims, roles.Author) || roles.HasRole(claims, roles.Organizer))
}

func (s *server) GetPlaylists(ctx context.Context, _ *proto.GetPlaylistsReq) (*proto.GetPlaylistsRsp, error) {
	if !canManagePlaylists(ctx) {
		return nil, status.Error(codes.PermissionDenied, "permission denied")
	}
	items, err := s.playlistService.List(ctx)
	if err != nil {
		return nil, playlistErrorStatus(err, "не удалось получить плейлисты")
	}
	result := &proto.GetPlaylistsRsp{}
	for _, item := range items {
		result.Playlists = append(result.Playlists, mapPlaylist(item))
	}
	return result, nil
}

func (s *server) CreatePlaylist(ctx context.Context, req *proto.CreatePlaylistReq) (*proto.CreatePlaylistRsp, error) {
	if !canManagePlaylists(ctx) {
		return nil, status.Error(codes.PermissionDenied, "permission denied")
	}
	item, err := s.playlistService.Create(ctx, req.GetName())
	if err != nil {
		return nil, playlistErrorStatus(err, "не удалось создать плейлист")
	}
	return &proto.CreatePlaylistRsp{Playlist: mapPlaylist(item)}, nil
}

func (s *server) UpdatePlaylist(ctx context.Context, req *proto.UpdatePlaylistReq) (*proto.UpdatePlaylistRsp, error) {
	if !canManagePlaylists(ctx) {
		return nil, status.Error(codes.PermissionDenied, "permission denied")
	}
	item, err := s.playlistService.Update(ctx, int(req.GetID()), req.GetName())
	if err != nil {
		return nil, playlistErrorStatus(err, "не удалось изменить плейлист")
	}
	return &proto.UpdatePlaylistRsp{Playlist: mapPlaylist(item)}, nil
}

func (s *server) DeletePlaylist(ctx context.Context, req *proto.DeletePlaylistReq) (*proto.DeletePlaylistRsp, error) {
	if !canManagePlaylists(ctx) {
		return nil, status.Error(codes.PermissionDenied, "permission denied")
	}
	if err := s.playlistService.Delete(ctx, int(req.GetID())); err != nil {
		return nil, playlistErrorStatus(err, "не удалось удалить плейлист")
	}
	return &proto.DeletePlaylistRsp{}, nil
}

func (s *server) UploadPlaylistTrack(ctx context.Context, req *proto.UploadPlaylistTrackReq) (*proto.UploadPlaylistTrackRsp, error) {
	if !canManagePlaylists(ctx) {
		return nil, status.Error(codes.PermissionDenied, "permission denied")
	}
	if err := s.playlistService.UploadTrack(
		ctx,
		int(req.GetPlaylistID()),
		req.GetName(),
		req.GetFilename(),
		req.GetData(),
	); err != nil {
		return nil, playlistErrorStatus(err, "не удалось загрузить MP3")
	}
	item, err := s.playlistService.Get(ctx, int(req.GetPlaylistID()))
	if err != nil {
		return nil, playlistErrorStatus(err, "не удалось получить плейлист")
	}
	return &proto.UploadPlaylistTrackRsp{Playlist: mapPlaylist(item)}, nil
}

func (s *server) DeletePlaylistTrack(ctx context.Context, req *proto.DeletePlaylistTrackReq) (*proto.DeletePlaylistTrackRsp, error) {
	if !canManagePlaylists(ctx) {
		return nil, status.Error(codes.PermissionDenied, "permission denied")
	}
	if err := s.playlistService.DeleteTrack(
		ctx,
		int(req.GetPlaylistID()),
		int(req.GetTrackID()),
	); err != nil {
		return nil, playlistErrorStatus(err, "не удалось удалить трек")
	}
	return &proto.DeletePlaylistTrackRsp{}, nil
}

func (s *server) SetScenarioPlaylist(ctx context.Context, req *proto.SetScenarioPlaylistReq) (*proto.SetScenarioPlaylistRsp, error) {
	claims, err := claimsFromContext(ctx)
	if err != nil {
		return nil, err
	}
	if !roles.HasRole(claims, roles.Author) {
		return nil, status.Error(codes.PermissionDenied, "permission denied")
	}
	if err := s.playlistService.SetScenario(
		ctx,
		int(req.GetID()),
		int(req.GetPlaylistID()),
	); err != nil {
		return nil, playlistErrorStatus(err, "не удалось назначить плейлист сценарию")
	}
	return &proto.SetScenarioPlaylistRsp{}, nil
}

func (s *server) GetGameMusic(ctx context.Context, req *proto.GetGameMusicReq) (*proto.GetGameMusicRsp, error) {
	if !canManageScreens(ctx) {
		return nil, status.Error(codes.PermissionDenied, "permission denied")
	}
	state, err := s.playlistService.GetGame(ctx, int(req.GetGameID()))
	if err != nil {
		return nil, playlistErrorStatus(err, "не удалось получить музыку игры")
	}
	playlists, err := s.playlistService.List(ctx)
	if err != nil {
		return nil, playlistErrorStatus(err, "не удалось получить плейлисты")
	}
	result := &proto.GetGameMusicRsp{State: mapMusicState(state)}
	for _, item := range playlists {
		result.Playlists = append(result.Playlists, mapPlaylist(item))
	}
	if state.ScenarioID != nil {
		result.ScenarioPlaylistId = int32(*state.ScenarioID)
	}
	if state.GameID != nil {
		result.GamePlaylistId = int32(*state.GameID)
	}
	return result, nil
}

func (s *server) SetGameMusic(ctx context.Context, req *proto.SetGameMusicReq) (*proto.SetGameMusicRsp, error) {
	if !canManageScreens(ctx) {
		return nil, status.Error(codes.PermissionDenied, "permission denied")
	}
	state, err := s.playlistService.SetGame(
		ctx,
		int(req.GetGameID()),
		int(req.GetPlaylistID()),
		int(req.GetTrackIndex()),
		req.GetPositionMs(),
		req.GetVolume(),
		req.GetLoop(),
		int32(req.GetPlayback()),
	)
	if err != nil {
		return nil, playlistErrorStatus(err, "не удалось изменить музыку игры")
	}
	return &proto.SetGameMusicRsp{State: mapMusicState(state)}, nil
}