package main

import (
	"src.dualinventive.com/go/users-service/internal/domain"
	"src.dualinventive.com/go/users-service/rest/models"
	"src.dualinventive.com/go/users-service/rest/server/operations/users"
)

func mapUser(user *domain.User) *models.User {
	if user == nil {
		return nil
	}

	mapped := &models.User{
		ID:        int64(user.ID),
		Username:  user.UserName,
		Firstname: user.FirstName,
		Lastname:  user.LastName,
		Reference: user.Reference,
	}

	mapped.Company = &models.UserCompany{
		ID:   int64(user.Company.ID),
		Name: user.Company.Name,
		Code: user.Company.Code,
	}

	userRoles := make([]*models.UserRolesItems0, len(user.Roles))
	for i, domainRole := range user.Roles {
		modelRole := &models.UserRolesItems0{}
		modelRole.Name = domainRole.Name

		rights := make([]string, len(domainRole.Rights))
		for j, domainRight := range domainRole.Rights {
			rights[j] = domainRight.Code
		}

		modelRole.Rights = rights
		userRoles[i] = modelRole
	}

	mapped.Roles = userRoles

	return mapped
}

func mapUsers(users []domain.User, count uint64) *models.UsersList {
	if users == nil {
		return nil
	}

	userslist := models.UsersList{
		Users: []*models.User{},
		Count: int64(count),
	}

	for _, user := range users {
		user := user
		userslist.Users = append(userslist.Users, mapUser(&user))
	}

	return &userslist
}

func mapFilter(params *users.ListUsersParams) domain.UsersFilter {
	filter := make(domain.UsersFilter)
	if params.Reference != nil && len(*params.Reference) != 0 {
		filter[domain.UsersFilterTypeReference] = *params.Reference
	}
	return filter
}

func mapSortCol(sortcol string) domain.SortCol {
	sort := domain.SortCol(sortcol)
	switch sort {
	case domain.SortColIDAsc,
		domain.SortColIDDesc,
		domain.SortColNameAsc,
		domain.SortColNameDesc:
		return sort
	case "name":
		return domain.SortColNameAsc
	default:
		return domain.SortColIDAsc
	}
}