package "handler"

func (h *Handler) GetReport(ctx context.Context, body *reportproto.GetReportRequest) (*reportproto.GetReportResponse, error) {
    // Generate report
    result, err := report.Build(ctx, body.ReportType)
    if err != nil {
        return nil, error
    }

    return &reportproto.ReportResponse{report: result}, nil
}

package "report"

func Build(ctx context.Context, reportType string) (Report, error) {
    // We choose strategy to build report
    var reportBuilder reporter
    switch reportType {
    case constants.ReportTypeUsers:
        reportBuilder = allUsersReporter{}
    case constants.ReportTypeRoles:
        reportBuilder = roleReporter{}
    case constants.ReportTypePolicies:
        reportBuilder = policyReporter{}
    default:
        return nil, fmt.Errorf("invalid_report_type: Invalid report type provided")
    }

    report, err := reportBuilder.build(ctx, w)

    return report, err
}

package handler

func (h *Handler) HandleGETReadEmployee(ctx context.Context, body *hrsystemproto.GETReadEmployeeRequest) (*hrsystemproto.GETReadEmployeeResponse, error) {
    if body.EmployeeId == "" {
        return nil, validation.ErrMissingParam("employee_id")
    }

    // client is based on Go net/http package and does request to 3rd party system
    employee, err := client.GetEmployee(ctx, body.EmployeeId)
    if err != nil {
        return nil, fmt.Errorf("failed to read employee")
    }

    marshalled, err := marshaling.EmployeeToProto(ctx, employee)
    if err != nil {
        return nil, fmt.Errorf("failed to marshal employee")
    }
    return &hrsystemproto.GETReadEmployeeResponse{
        Employee: marshalled,
    }, nil
}

func createReportRows(ctx context.Context, employeeProfiles []profile) (map[string]reportRow, error) {
    numOfEmployees := len(employeeProfiles)
    rowsChan := make(chan reportRow, numOfEmployees)
    concurrencyLimiter := semaphore.NewWeighted(100)

    // Fan-out stage, create rows of assignment report concurrenty
    for _, employee := range employeeProfiles {
        // Acquire a "token" from semaphore, block if none available.
        if err := concurrencyLimiter.Acquire(ctx, 1); err != nil {
            return nil, err
        }

        go func(curProfile profile, rowsChan chan<- reportRow, concurrencyLimiter <-chan struct{}) {
            // Release the "token" back to semaphore
            defer concurrencyLimiter.Release(1)

            rowsChan <- newRow(ctx, curProfile)
        }(employee, rowsChan, concurrencyLimiter)
    }

    // Fan-in stage, all created rows go into one data structure
    // As we know the exact number of rows, we can use a simple for loop
    // and wait for all of them to be created and sent to the channel.
    rows := make(map[string]reportRow, numOfEmployees)
    for i := 0; i < numOfEmployees; i++ {
        assignment := <-rowsChan
        rows[assignment.id] = assignment
    }

    return rows, nil
}