package resolver

import (
	"context"

	"git.aiterp.net/rpdata/api/internal/session"
	"git.aiterp.net/rpdata/api/model/change"
	"git.aiterp.net/rpdata/api/model/channel"
	"git.aiterp.net/rpdata/api/resolver/types"
)

// ChannelArgs is args for channel query
type ChannelArgs struct {
	Name string
}

// Channel implements the channel query
func (r *QueryResolver) Channel(ctx context.Context, args *ChannelArgs) (*types.ChannelResolver, error) {
	channel, err := channel.FindName(args.Name)
	if err != nil {
		return nil, err
	}

	return &types.ChannelResolver{C: channel}, nil
}

// ChannelsArgs is args for channel query
type ChannelsArgs struct {
	Logged *bool
}

// Channels implements the channels query
func (r *QueryResolver) Channels(ctx context.Context, args *ChannelsArgs) ([]*types.ChannelResolver, error) {
	channels, err := channel.List(args.Logged != nil && *args.Logged)
	if err != nil {
		return nil, err
	}

	resolvers := make([]*types.ChannelResolver, len(channels))
	for i := range channels {
		resolvers[i] = &types.ChannelResolver{C: channels[i]}
	}

	return resolvers, nil
}

// ChannelAddArgs is input for the addChannel mutation
type ChannelAddArgs struct {
	Input *struct {
		Name         string
		Logged       *bool
		Hub          *bool
		EventName    *string
		LocationName *string
	}
}

// AddChannel resolves the addChannel mutation
func (r *MutationResolver) AddChannel(ctx context.Context, args *ChannelAddArgs) (*types.ChannelResolver, error) {
	input := args.Input

	user := session.FromContext(ctx).User()
	if user == nil || !user.Permitted("channel.add") {
		return nil, ErrUnauthorized
	}

	logged := input.Logged != nil && *input.Logged

	hub := input.Hub != nil && *input.Hub

	eventName := ""
	if input.EventName != nil {
		eventName = *input.EventName
	}

	locationName := ""
	if input.LocationName != nil {
		locationName = *input.LocationName
	}

	channel, err := channel.New(input.Name, logged, hub, eventName, locationName)
	if err != nil {
		return nil, err
	}

	go change.Submit("Channel", "add", user.ID, channel.Name, map[string]interface{}{
		"logged":   channel.Logged,
		"hub":      channel.Hub,
		"location": input.LocationName,
		"event":    input.EventName,
	})

	return &types.ChannelResolver{C: channel}, nil
}

// ChannelEditArgs is input for the editChannel mutation
type ChannelEditArgs struct {
	Input *struct {
		Name         string
		Logged       *bool
		Hub          *bool
		EventName    *string
		LocationName *string
	}
}

// EditChannel resolves the editChannel mutation
func (r *MutationResolver) EditChannel(ctx context.Context, args *ChannelEditArgs) (*types.ChannelResolver, error) {
	input := args.Input

	user := session.FromContext(ctx).User()
	if user == nil || !user.Permitted("channel.edit") {
		return nil, ErrUnauthorized
	}

	channel, err := channel.FindName(input.Name)
	if err != nil {
		return nil, err
	}

	err = channel.Edit(input.Logged, input.Hub, input.EventName, input.LocationName)
	if err != nil {
		return nil, err
	}

	go change.Submit("Channel", "edit", user.ID, channel.Name, map[string]interface{}{
		"logged":   input.Logged,
		"hub":      input.Hub,
		"location": input.LocationName,
		"event":    input.EventName,
	})

	return &types.ChannelResolver{C: channel}, nil
}

// RemoveChannel resolves the editChannel mutation
func (r *MutationResolver) RemoveChannel(ctx context.Context, args ChannelArgs) (*types.ChannelResolver, error) {
	user := session.FromContext(ctx).User()
	if user == nil || !user.Permitted("channel.remove") {
		return nil, ErrUnauthorized
	}

	channel, err := channel.FindName(args.Name)
	if err != nil {
		return nil, err
	}

	err = channel.Remove()
	if err != nil {
		return nil, err
	}

	go change.Submit("Channel", "remove", user.ID, channel.Name, nil)

	return &types.ChannelResolver{C: channel}, nil
}