# To remove the WARNING

# no visible binding for global variable

utils::globalVariables(c(

  "type", "name", "value", "unit", "uncertainty",

  "timing", "age", "length", "year",

  # Used in initialize_comp dplyr code

  "valid_n"

))

#' Initialize a generic module

#'

#' @description

#' Initializes a generic module by setting up its fields based on the provided

#' `module_name`.

#' @param parameters A tibble. Contains parameters and modules required for

#'   initialization.

#' @param data An S4 object. FIMS input data.

#' @param module_name A character. Name of the module to initialize (e.g.,

#'   "Population" or "Fleet").

#' @param fleet_name A character. Name of the fleet to initialize. If not

#'   specified, the module will be initialized without fleet-specific data.

#' @return

#' The initialized module as an object.

#' @noRd

initialize_module <- function(parameters, data, module_name, fleet_name = NA_character_) {

    # Using !! to unquote the variables

  }

    # Combine module_type and module_name into a single string

        # Replace NAs with ""

      )

    ) |>

    # Remove certain fields for the Fleet module

    ))

      # Assign each value to the corresponding position in the parameter vector

      )

      # Set the estimation information for the entire parameter vector

    } else {

        # Right now we can also remove n_lengths because the default is 0

      ))

    }

    ))

  }

  # Populate fields based on common and specific settings

  # TODO:

  # - Population interface

  #   - Update the Population interface to consistently use n_ages and n_years,

  #     as done in the S4 data1 object.

  #     Update as needed.

  #   - Add n_fleets to data1. Should n_fleets include both

  #     fishing and survey fleets? Currently, data1@fleets equals 1.

  # - Fleet

  #   - Reconsider exposing `log_expected_index` and

  #     `agecomp_proportion` to users. Their IDs are linked with

  #     index and agecomp distributions. No input values are required.

  )

  )

  )

          # Or we can use get_n_fleets(data),

        )

      )

      )

      })

    } else {

      )

    }

  }

}

# TODO: Determine the relationship between distributions and the

# recruitment module, and implement the appropriate logic to retrieve

# distribution information.

#' Initialize a distribution module

#'

#' @description

#' Initializes a distribution module by setting up its fields based on the

#' distribution name and type. Supports both "data" and "process" types.

#' @param module_input A list. Contains parameters for initializing the

#'   distribution.

#' @param distribution_name A character. Name of the distribution to initialize.

#' @param distribution_type A character. Type of distribution, either "data" or

#'   "process".

#' @param linked_ids A vector. Named vector of linked IDs required for the

#'   distribution, such as data_link and fleet_link for setting up index

#'   distribution.

#' @rdname initialize_module

#' @return

#' The initialized distribution module as an object.

#' @noRd

initialize_distribution <- function(

  module_input,

  distribution_name,

  distribution_type = c("data", "process"),

  linked_ids

) {

  # Input checks

  # Check if distribution_name is provided

  }

  # Validate module_input

  }

  # Validate distribution_type as "data" or "process"

  # Validate linked_ids as a named vector with required elements for "data" type

  ) {

    )

  }

  # Get distribution value and initialize the module

    )

  }

  )

    )

  }

    "data" = {

      # Data distribution initialization

      )

    },

    "process" = {

      # Process distribution initialization

    }

  )

  # Final message to confirm success

  ))

}

#' Initialize a recruitment module

#'

#' @description

#' Initializes a recruitment module by setting up fields. This function uses

#' the `initialize_module` function to handle specific requirements for

#' recruitment initialization.

#' @inheritParams initialize_module

#' @return

#' The initialized recruitment module as an object.

#' @noRd

initialize_recruitment <- function(parameters, data) {

  )

}

#' Initialize a growth module

#'

#' @description

#' Initializes a growth module by setting up fields. This function uses

#' the `initialize_module` function to handle specific requirements for

#' growth initialization.

#' @inheritParams initialize_module

#' @return

#' The initialized growth module as an object.

#' @noRd

initialize_growth <- function(parameters, data) {

  )

}

#' Initialize a maturity module

#'

#' @description

#' Initializes a maturity module by setting up fields. This function uses

#' the `initialize_module` function to handle specific requirements for

#' maturity initialization.

#' @inheritParams initialize_module

#' @return

#' The initialized maturity module as an object.

#' @noRd

initialize_maturity <- function(parameters, data) {

  )

}

#' Initialize a population module.

#'

#' @description

#' Initializes a population module by setting up fields. This function uses

#' the `initialize_module` function to handle specific requirements for

#' population initialization.

#' @inheritParams initialize_module

#' @param linked_ids A vector. Named vector of linked IDs required for the

#'   population, including IDs for "growth", "maturity", and "recruitment".

#' @return

#' The initialized population module as an object.

#' @noRd

initialize_population <- function(parameters, data, linked_ids) {

    ))

  }

  )

  # Link up the recruitment, growth, and maturity modules with

  # this population module

  # Link fleets to module

  }

}

#' Initialize a selectivity module.

#'

#' @description

#' Initializes a selectivity module by setting up fields. This function uses

#' the `initialize_module` function to handle specific requirements for

#' population initialization.

#' @inheritParams initialize_module

#' @param fleet_name A character. Name of the fleet to initialize.

#' @return

#' The initialized selectivity module as an object.

#' @noRd

initialize_selectivity <- function(parameters, data, fleet_name) {

  )

}

# TODO: Do we want to put initialize_selectivity(), initialize_index(), and

# initial_age_comp() inside of initialize_fleet()?

#' Initialize a fleet module

#'

#' @description

#' Initializes a fleet module by setting up its fields. It links selectivity,

#' index, and age-composition modules.

#' @inheritParams initialize_module

#' @param fleet_name A character. Name of the fleet to initialize.

#' @param linked_ids A vector. Named vector of linked IDs required for the

#'  fleet, including IDs for "selectivity", "landings", "index", "age_comp", and "length_comp".

#' @return

#' The initialized fleet module as an object.

#' @noRd

initialize_fleet <- function(parameters, data, fleet_name, linked_ids) {

  )

  # Link the observed landings data to the fleet module using its associated ID

  # if the data type includes "landings" and if "Landings" exists in the data distribution

  # specification

  }

  # Link the observed index data to the fleet module using its associated ID

  # if the data type includes "index" and if "Index" exists in the data distribution

  # specification

  }

  # Link the observed age composition data to the fleet module using its associated ID

  # if the data type includes "age_comp" and if "AgeComp" exists in the data distribution

  # specification

  }

  # Link the observed length composition data to the fleet module using its associated ID

  # if the data type includes "length_comp" and if "LengthComp" exists in the data

  # distribution specification

  }

}

#' Initialize a landings module

#'

#' @description

#' Initializes a landings module based on the provided data and fleet name.

#' @inheritParams initialize_module

#' @param fleet_name A character. Name of the fleet for which the landings module

#'   is initialized.

#' @return

#' The initialized landings module as an object.

#' @noRd

initialize_landings <- function(data, fleet_name) {

  # Check if the specified fleet exists in the data

  }

  ) |>

    )

  } else {

  }

}

#' Initialize an index module

#'

#' @description

#' Initializes an index module based on the provided data and fleet name.

#' @inheritParams initialize_module

#' @param fleet_name A character. Name of the fleet for which the index module

#'   is initialized.

#' @return

#' The initialized index module as an object.

#' @noRd

initialize_index <- function(data, fleet_name) {

  # Check if the specified fleet exists in the data

  }

  ) |>

    )

  } else {

  }

}

#' Initialize a composition module

#'

#' Several types of composition modules exist and this function acts as a

#' generic interface to initialize any type, for example assigning

#' age-composition data to a given fleet would be an example of initializing

#' a composition module.

#'

#' @inheritParams initialize_module

#' @param fleet_name A character specifying the name of the fleet for which

#'   composition data is initialized.

#' @param type A character specifying the composition type, where the default

#'   is `"AgeComp"`. At the moment, one can initialize `"AgeComp"` or

#'   `"LengthComp"` modules.

#' @return

#' The initialized composition module as an object.

#' @noRd

initialize_comp <- function(data,

                            fleet_name,

                            type = c("AgeComp", "LengthComp")) {

  # Edit this list if a new type is added

  # Set up the specifics for the given type.

    ),

    )

  )

  # Ensures the user input matches the options provided,

  #   if not, then match.arg() throws an error

  # Select the row in comp_types that matches the user's type selection

  # Check if the specified fleet exists in the data

  }

  )

  # Validate that the fleet's composition data is available

    ))

  }

      ) |>

      ) |>

      ) |>

    ))

  }

  )

}

#' Initialize FIMS modules

#'

#' @description

#' Initializes multiple modules within the Fisheries Integrated Modeling System

#' (FIMS), including fleet, recruitment, growth, maturity, and population

#' modules. This function iterates over the provided fleets, setting up

#' necessary sub-modules such as selectivity, index, and age composition. It

#' also sets up distribution models for fishery index and age-composition data.

#' @param parameters A tibble. Contains parameters and modules required for

#'   initialization.

#' @param data An S4 object. FIMS input data.

#' @return

#' A list containing parameters for the initialized FIMS modules, ready for use

#' in TMB modeling.

#' @export

initialize_fims <- function(parameters, data) {

  # Validate parameters input

  }

  # Check if parameters is a nested tibble. If so, unnest parameters

  }

  # Check if estimation_type is within "constant", "fixed_effect", "random_effect"

    ))

  }

  # Clear any previous FIMS settings

    ))

  }

  # Initialize lists to store fleet-related objects

    )

    )

    # Initialize landings module if the data type includes "landings" and

    # if "Landings" exists in the data distribution specification

      # Initialize landings module for the current fleet

      )

      # Add the module ID for the initialized landings to the list of fleet module IDs

      )

    }

    # Initialize index module if the data type includes "index" and

    # if "Index" exists in the data distribution specification

      # Initialize index module for the current fleet

      )

      # Add the module ID for the initialized index to the list of fleet module IDs

      )

    }

    # Initialize age composition module if the data type includes "age_comp" and

    # if "AgeComp" exists in the data distribution specification

      # Initialize age composition module for the current fleet

      )

      # Add the module ID for the initialized age composition to the list of fleet module IDs

      )

    }

    # Initialize length composition module if the data type includes "length_comp" and

    # if "LengthComp" exists in the data distribution specification

      # Initialize length composition module for the current fleet

      )

      # Add the module ID for the initialized length composition to the list of fleet module IDs

      )

    }

      # TODO: need to remove linked_ids from the function and add module_id to the

      # parameters tibble

    )

      )

      ))

    }

        # TODO: need to update family and match options from the distribution

        # column from the parameters tibble

      )

    }

        # TODO: need to update family and match options from the distribution

        # column from the parameters tibble

      )

    }

        # TODO: need to update family and match options from the distribution

        # column from the parameters tibble

      )

    }

        # TODO: need to update family and match options from the distribution

        # column from the parameters tibble

      )

    }

  }

  # Recruitment

  # create new module in the recruitment class (specifically Beverton--Holt,

  # when there are other options, this would be where the option would be

  # chosen)

  )

    # TODO: need to revisit initialize_process_structure and add R tests

    )

  } else {

    # Initialize_process_distribution for each par

        # TODO: need to update family and match options from the distribution

        # column from the parameters tibble

        # TODO: need to remove is_random_effect and match options from the

        # estimation_type from the parameters tibble

      )

      )

    })

  }

  # Growth

  )

  # Maturity

  )

  )

  # Population

    # TODO: need to remove linked_ids from the function and add module_id to the

    # parameters tibble

  )

  # Set-up TMB

  # Hard code to be a catch-at-age model

  # Create parameter list from Rcpp modules

    ),

  )

}

#' Set parameter vector values based on module input

#'

#' @description

#' This function sets the parameter vector values in a module based on the

#' provided module input, including both initial values and estimation

#' information.

#' @param field A character string specifying the field name of the parameter

#'   vector to be updated.

#' @param module A module object in which the parameter vector is to be set.

#' @param module_input A list containing input parameters for the module,

#'   including value and estimation information for the parameter vector.

#' @return

#' Modified module object.

#' @noRd

set_param_vector <- function(field, module, module_input) {

  # Check if field_name is a non-empty character string

    ))

  }

  # Check if module is a reference class

    ))

  }

  # Check if module_input is a list

  }

  # Extract the value of the parameter vector

  # Check if both value and estimation information are present

    ))

  }

  # Resize the field in the module

  # Assign each value to the corresponding position in the parameter vector

  }

}

# TODO: Document the names/items in each list that are returned

#' Create default parameters for a FIMS model

#'

#' @description

#' This function generates a Fisheries Integrated Modeling System (FIMS) model

#' configuration with detailed parameter specifications. This function takes a

#' high-level configuration `tibble` and generates the corresponding parameters

#' with default initial values and estimation settings required to build and run

#' the model.

#'

#' @details

#' The function processes the input `configurations` tibble, which defines the

#' modules for different model components (e.g., `"Selectivity"`, `"Recruitment"`).

#' For each module specified, it calls internal helper functions to create a

#' default set of parameters. For example, if a fleet's selectivity is configured

#' as `"Logistic"`, it generates initial values for `"inflection_point"` and

#' `"slope"`.

#'

#' @param configurations A tibble of model configurations. Typically created

#'   by [create_default_configurations()]. Users can modify this tibble

#'   to customize the model structure before generating default parameters.

#' @param data An S4 object. FIMS input data.

#' @return A `tibble` with default model parameters. The tibble has a nested

#'   structure with the following top-level columns.

#' \describe{

#'   \item{\code{model_family}:}{The specified model family (e.g.,

#'     "catch_at_age").}

#'   \item{\code{module_name}:}{The name of the FIMS module (e.g.,

#'     "Data", "Selectivity", "Recruitment", "Growth", "Maturity").}

#'   \item{\code{fleet_name}:}{The name of the fleet the module applies to. This

#'     will be `NA` for non-fleet-specific modules like "Recruitment".}

#'   \item{\code{data}:}{A list-column containing a `tibble` with detailed

#'     parameters. Unnesting this column reveals:

#'     \describe{

#'       \item{\code{module_type}:}{The specific type of the module (e.g.,

#'         "Logistic" for a "Selectivity" module).}

#'       \item{\code{label}:}{The name of the parameter (e.g., "inflection_point").}

#'       \item{\code{distribution_link}:}{The component the distribution module

#'         links to.}

#'       \item{\code{age}:}{The age the parameter applies to.}

#'       \item{\code{length}:}{The length bin the parameter applies to.}

#'       \item{\code{time}:}{The time step (i.e., year) the parameter applies to.}

#'       \item{\code{value}:}{The initial value of the parameter.}

#'       \item{\code{estimation_type}:}{The type of estimation (e.g.,

#'         "constant", "fixed_effects", "random_effects").}

#'       \item{\code{distribution_type}:}{The type of distribution (e.g., "Data",

#'         "process").}

#'       \item{\code{distribution}:}{The name of distribution (e.g.,

#'         "Dlnorm", `Dmultinom`).}

#'     }

#'   }

#' }

#' @export

#' @seealso

#' * [FIMSFrame()]

#' * [create_default_configurations()]

#' @examples

#' \dontrun{

#' # Load the example dataset and create a FIMS data frame

#' data("data1")

#' fims_frame <- FIMSFrame(data1)

#'

#' # Create default configurations

#' default_configurations <- create_default_configurations(fims_frame)

#'

#' # Create default parameters

#' default_parameters <- create_default_parameters(

#'   configurations = default_configurations,

#'   data = fims_frame

#' ) |>

#'   tidyr::unnest(cols = data)

#'

#' # Update selectivity parameters for survey1

#' updated_parameters <- default_parameters |>

#'   dplyr::rows_update(

#'     tibble::tibble(

#'       fleet_name = "survey1",

#'       label = c("inflection_point", "slope"),

#'       value = c(1.5, 2)

#'     ),

#'     by = c("fleet_name", "label")

#'   )

#'

#' # Do the same as above except, model fleet1 with double logistic selectivity

#' # To see required parameters for double logistic selectivity, run

#' # show(DoubleLogisticSelectivity)

#' parameters_with_double_logistic <- default_configurations |>

#'   tidyr::unnest(cols = data) |>

#'   dplyr::rows_update(

#'     tibble::tibble(

#'       module_name = "Selectivity",

#'       fleet_name = "fleet1",

#'       module_type = "DoubleLogistic"

#'     ),

#'     by = c("module_name", "fleet_name")

#'   ) |>

#'   create_default_parameters(

#'     data = fims_frame

#'   )

#' }

create_default_parameters <- function(

  configurations,

  data

) {

  # FIXME: use default values if there are no fleets info passed into the

  # function or a fleet is not present but it has data? Maybe we don't want the

  # latter because it could be that we want to drop a fleet from a model but we

  # don't want to alter the data?

  # Check if configurations is a nested tibble. If so, unnest configurations

  } else {

  }

  # Create fleet parameters

      )

    }

  ) |>

    # bind_rows now directly takes the list of tibbles from map()

  # Create recruitment parameters

  )

  # Create maturity parameters

  )

  # Create population parameters

  # Handle population parameters based on recruitment form

  )

  # Compile temps

  )

  # Merge with configuration_unnest

  ) |>

    ) |>

    ) |>

}

#' Create default parameters for a FIMS model

#' @description

#' This function creates a template for default parameters used in a Fisheries

#' Integrated Modeling System (FIMS) model. The template includes fields for

#' module name, module type, label, fleet name, population name, age, length,

#' time, value, estimation type, distribution type, and distribution.

#' @param n_parameters An integer specifying the number of parameters in the template.

#' @return

#' A tibble template for a FIMS model.

#' @noRd

#' @examples

#' FIMS:::create_default_parameters_template(n_parameters = 3)

create_default_parameters_template <- function(n_parameters = 1) {

  ) |>

}

#' Create default population parameters

#'

#' @description

#' This function sets up default parameters for a population module.

#' @details

#' The natural log of the initial numbers at age (`log_init_naa.value`) is set based on

#' unexploited recruitment and natural mortality.

#' @param unnested_configurations A tibble of model configurations. Typically created

#'   by the `create_default_configurations()`.

#' @param data An S4 object. FIMS input data.

#' @param log_rzero A numeric value representing the natural log of unexploited

#'   recruitment.

#' @return

#' A tibble of default population parameters, including initial numbers at

#' age and natural mortality rate.

#' @noRd

create_default_Population <- function(

  unnested_configurations,

  data,

  log_rzero

) {

  # Input checks

  # Check if log_rzero is numeric

    )

  }

  # Extract necessary values from data

  # Set natural mortality rate

  # Calculate initial numbers at age based on log_rzero and M_value

  # Create a list of default parameters

  ) |>

    # Add the module type, label, value, and estimation type

    ) |>

    ) |>

    )

}

#' Create default logistic parameters

#'

#' @description

#' This function sets up default parameters for a logistic function. There are

#' two specified parameters, the inflection point and slope.

#' @return

#' A tibble containing the default logistic parameters, with inflection_point and

#' slope values and their estimation status.

#' @noRd

create_default_Logistic <- function() {

  # Create a template for default parameters

    # Add the module type, label, value, and estimation type

    )

}

#' Create default double logistic parameters

#'

#' @description

#' This function sets up default parameters for a double logistic function.

#' There four specified parameters, two for the ascending and two for the

#' descending inflection points and slopes.

#' @return

#' A tibble containing the default double logistic parameters,

#' inflection_point_asc, slope_asc, inflection_point_desc, and slope_desc

#' values and their estimation status.

#' @noRd

create_default_DoubleLogistic <- function(module_name = NA_character_) {

      # TODO: Determine if inflection_point_desc should really be 4?

    )

}

#' Create default selectivity parameters

#'

#' @description

#' This function sets up default parameters for a selectivity module.

#' @param form A string specifying the desired form of selectivity. Allowable

#'   forms include `r toString(formals(create_default_selectivity)[["form"]])`

#'   and the default is

#'   `r toString(formals(create_default_selectivity)[["form"]][1])`.

#' @return

#' A tibble is returned with the default parameter values for the specified form

#' of selectivity.

#' @noRd

create_default_selectivity <- function(

  form = c("Logistic", "DoubleLogistic")

) {

  # Input checks

  # NOTE: All new forms of selectivity must be placed in the vector of default

  # arguments for `form` and their methods but be placed below in the call to

  # `switch`

  ) |>

    )

}

#' Create default fleet parameters

#'

#' @description

#' This function sets up default parameters for a fleet module. It compiles

#' selectivity parameters along with distributions for each type of data that

#' are present for the given fleet.

#'

#' @param unnested_configurations A tibble of model configurations. Typically

#'   created by the `create_default_configurations()`.

#' @param fleet_name A character. Name of the fleet.

#' @param data An S4 object. FIMS input data.

#' @return

#' A tibble with default parameters for the fleet.

#' @noRd

create_default_fleet <- function(unnested_configurations,

                                 current_fleet_name,

                                 data) {

  # Input checks

    ))

  }

    ))

  }

  # Create default selectivity parameters

  ) |>

    # Add fleet name

    )

  # Get types of data for this fleet from the data object

  # Get data likelihood distributions assigned for this fleet

  # Determine default fleet parameters based on types of data present

      )

      ) |>

      ),

      )

    ) |>

      )

  } else {

      )

  }

    ) |>

      )