# public functions
#   mod_out_ahv
#   mod_out_eo
#   mod_out_eo_llc
#   mod_out_iv
# private functions
#   mod_out_el


#' @title Output AHV
#'
#' @description Speichert den AHV Output
#'
#' @param path vector containing container path.
#'
#' @param path_out vector containing output path.
#'
#' @param tl_inp list containing input data AHV.
#'
#' @param tl_out_ahv list containing output data AHV.
#'
#' @return path_out_identifier path to output container
#'
#' @author [MAS BSV](mailto:sekretariat.mas@bsv.admin.ch)
#'
#' @export


mod_out_ahv <- function(path, path_out, tl_inp, tl_out_ahv) {

  # construct output path
  path_out_identifier <-
    path_out_resolve(path_out, tl_inp$PARAM_GLOBAL$identifier_number)

  # write csv
  tl_out_ahv1 <- tl_out_ahv
  tl_out_ahv1_names <- duplicated(names(tl_out_ahv1))
  tl_out_ahv2 <- tl_out_ahv1[tl_out_ahv1_names == FALSE] # avoid duplicates
  tl_out_ahv2_sorted_names <- sort(names(tl_out_ahv2))

  tl_out_ahv <- tl_out_ahv2[tl_out_ahv2_sorted_names] # sort names alphabetically

  if (tl_inp$PARAM_GLOBAL$flag_param_massn) {
    list_base_file <- c(
      "AHV_MASSNAHMEN_nom",
      "AHV_MASSNAHMEN_real",
      "AHV_FHH",
      "AHV_FHH_nom"
    )
  } else {
    list_base_file <- c("AHV_FHH", "AHV_FHH_nom")
  }


  if ("light_output" %in% colnames(tl_inp$PARAM_GLOBAL) == FALSE) {
      ### si le parametre n'est pas présent
      PARAM_NAME <- tl_out_ahv2_sorted_names[grepl("^PARAM", tl_out_ahv2_sorted_names)]
      if (!is.null(tl_inp$PARAM_OUTPUT)) {
        #### si le fichier output existe
        list_out <- tl_inp$PARAM_OUTPUT %>%
          pivot_longer(col = everything(), names_to = "name", values_to = "status") %>%
          filter(status == TRUE) %>%
          dplyr::select(name)
        list_out <- list_out[[1]]
        if (length(list_out) > 0) {
          ### si le fichier parametre contien quelque chose
          tl_out_ahv2_sorted_names <- c(
            PARAM_NAME,
            list_base_file,
            list_out
          )
        } else {
          PARAM_NAME <- tl_out_ahv2_sorted_names[grepl("^PARAM", tl_out_ahv2_sorted_names)]

          tl_out_ahv2_sorted_names <- c(
            PARAM_NAME,
            "AHV_MASSNAHMEN_nom",
            "AHV_MASSNAHMEN_real",
            "AHV_FHH",
            "AHV_FHH_nom"
          )
        }
      } else {
        ### si le fichier parametre n'existe pas
        PARAM_NAME <- tl_out_ahv2_sorted_names[grepl("^PARAM", tl_out_ahv2_sorted_names)]

        tl_out_ahv2_sorted_names <- c(
          PARAM_NAME,
          list_base_file
        )
      }
    } else {
      ### si le parametre est présent
      if (tl_inp$PARAM_GLOBAL$light_output) {
        ### si le parametre == TRUE
        if (!is.null(tl_inp$PARAM_OUTPUT)) {
          list_out <- tl_inp$PARAM_OUTPUT %>%
            pivot_longer(col = everything(), names_to = "name", values_to = "status") %>%
            filter(status == TRUE) %>%
            dplyr::select(name)
          list_out <- list_out[[1]]
          if (length(list_out) > 0) {
            PARAM_NAME <- tl_out_ahv2_sorted_names[grepl("^PARAM", tl_out_ahv2_sorted_names)]

            tl_out_ahv2_sorted_names <- c(
              PARAM_NAME,
              list_base_file,
              list_out
            )
          } else {
            PARAM_NAME <- tl_out_ahv2_sorted_names[grepl("^PARAM", tl_out_ahv2_sorted_names)]

            tl_out_ahv2_sorted_names <- c(
              PARAM_NAME,
              list_base_file
            )
          }
        } else {
          PARAM_NAME <- tl_out_ahv2_sorted_names[grepl("^PARAM", tl_out_ahv2_sorted_names)]

          tl_out_ahv2_sorted_names <- c(
            PARAM_NAME,
            list_base_file
          )
        }
      } else {
        ### si le parametre == FALSE
        tl_out_ahv_out <- tl_out_ahv
      }
    }

  tl_out_ahv_out <- tl_out_ahv2[tl_out_ahv2_sorted_names] # sort names alphabetically

  tidylist_write(
    c(
      tl_out_ahv_out
    ),
    path_out_identifier
  )

  tl_inp_clean <- 
    # Filtere die Namen der Dataframes, welche mit "PARAM" beginnen.
    tl_inp[names(tl_inp) %>% grep("^PARAM", ., value = TRUE)]

  tl_inp_clean <- tl_inp_clean[!duplicated(tl_inp_clean)]

  PARAM_ALL <-
    # Filtere die Namen der Dataframes, die mit "PARAM" beginnen
    tl_inp_clean[names(tl_inp_clean) %>% grep("^PARAM", ., value = TRUE)] %>%
    keep(~ nrow(.x) > 0) %>% # Behalte nur Dataframes mit mindestens einer Zeile
    imap(~ {
      df <- as.data.frame(.x) # Stelle sicher, dass jedes Element als Dataframe behandelt wird
      colnames(df) <- paste0(.y, ".", colnames(df)) # Füge Präfix mit dem Namen des Dataframes zu den Spaltennamen hinzu
      df # Gib den modifizierten Dataframe zurück
    }) %>%
    bind_cols() # Kombiniere alle Dataframes spaltenweise in einen einzigen Dataframe

  # write FHH diskontiert
  tl_inp$PARAM_GLOBAL$diskontierung <- TRUE
  write_file_ahv_fhh_flexible(
    PARAM_GLOBAL = tl_inp$PARAM_GLOBAL,
    AHV_FHH = tl_out_ahv$AHV_FHH,
    ECKWERTE_SCENARIO = tl_out_ahv$ECKWERTE_SCENARIO,
    ECKWERTE_EXTENDED = tl_out_ahv$ECKWERTE_EXTENDED,
    PARAM_ALL = PARAM_ALL,
    path_out_identifier = path_out_identifier,
    diskont = TRUE
  )
  # write FHH nominal
  tl_inp$PARAM_GLOBAL$diskontierung <- FALSE
  write_file_ahv_fhh_flexible(
    PARAM_GLOBAL = tl_inp$PARAM_GLOBAL,
    AHV_FHH = tl_out_ahv$AHV_FHH_nom,
    ECKWERTE_SCENARIO = tl_out_ahv$ECKWERTE_SCENARIO,
    ECKWERTE_EXTENDED = tl_out_ahv$ECKWERTE_EXTENDED,
    PARAM_ALL = PARAM_ALL,
    path_out_identifier = path_out_identifier,
    diskont = FALSE
  )

  if (tl_inp$PARAM_GLOBAL$flag_param_massn) {

    # write Massnahmentabelle diskontiert
    tl_inp$PARAM_GLOBAL$diskontierung <- TRUE
    tl_inp$PARAM_GLOBAL$output_path <- as_tibble(path_out_identifier)
    mod_ahv_output_massn_flexible(
      PARAM_GLOBAL = tl_inp$PARAM_GLOBAL,
      ANT_AJO_FLEX = tl_inp$ANT_AJO_FLEX,
      AHV_MASSNAHMEN = tl_out_ahv$AHV_MASSNAHMEN_real,
      PARAM_ALL = PARAM_ALL,
      ECKWERTE_SCENARIO = tl_out_ahv$ECKWERTE_SCENARIO
    )
    
    # write Massnahmentabelle nominal
    tl_inp$PARAM_GLOBAL$diskontierung <- FALSE
    tl_inp$PARAM_GLOBAL$output_path <- as_tibble(path_out_identifier)
    mod_ahv_output_massn_flexible(
      PARAM_GLOBAL = tl_inp$PARAM_GLOBAL,
      ANT_AJO_FLEX = tl_inp$ANT_AJO_FLEX,
      AHV_MASSNAHMEN = tl_out_ahv$AHV_MASSNAHMEN_nom,
      PARAM_ALL = PARAM_ALL,
      ECKWERTE_SCENARIO = tl_out_ahv$ECKWERTE_SCENARIO
    )
  }


  # Write Tabelle exogenen Indikatoren
  mod_ahv_output_exogenen_indikatoren(tl_inp$PARAM_GLOBAL,
                                      tl_out_ahv$EXOGENE_TABELLE,
                                      tl_out_ahv$ECKWERTE_SCENARIO,
                                      path_out_identifier)

  # Store params
  copy_param(path, path_out_identifier, tl_inp)

  return(path_out_identifier)
}


#' @title Output EO
#'
#' @description Speichert den EO Output
#'
#' @param path vector containing container path.
#'
#' @param path_out vector containing output path.
#'
#' @param tl_inp_eo list containing input data EO.
#'
#' @param tl_out_eo list containing output data EO.
#'
#' @return path_out_identifier path to output container
#'
#' @export


mod_out_eo <- function(path,
                       path_out,
                       tl_inp_eo,
                       tl_out_eo) {


  # construct output path
  path_out_identifier <-
    path_out_resolve(path_out, tl_inp_eo$PARAM_GLOBAL$identifier_number)

  # write csv
  tl_csvtowrite <- c(
    tl_out_eo
  )

  tl_csvtowrite1 <- tl_csvtowrite
  tl_csvtowrite1_names <- duplicated(names(tl_csvtowrite1))
  tl_csvtowrite2 <- tl_csvtowrite1[tl_csvtowrite1_names == FALSE] # avoid duplicates
  tl_csvtowrite2_sorted_names <- sort(names(tl_csvtowrite2))
  tl_csvtowrite <- tl_csvtowrite2[tl_csvtowrite2_sorted_names] # sort names alphabetically

  if ("flag_param_eo_massn" %in% colnames(tl_inp_eo$PARAM_GLOBAL)) {
      if (tl_inp_eo$PARAM_GLOBAL$flag_param_eo_massn) {
        list_base_file <- c(
          "EO_MASSNAHMEN_nom",
          "EO_MASSNAHMEN_real",
          "EO_FHH_nom",
          "EO_FHH_real"
        )
      } else {
        list_base_file <- c("EO_FHH_nom", "EO_FHH_real")
      }
    } else {
      list_base_file <- c("EO_FHH_nom", "EO_FHH_real")
    }

  if ("light_output" %in% colnames(tl_inp_eo$PARAM_GLOBAL) == FALSE) {
      ### si le parametre light_output n'est pas présent
      PARAM_NAME <- tl_csvtowrite2_sorted_names[grepl("^PARAM", tl_csvtowrite2_sorted_names)]
      if (!is.null(tl_inp_eo$PARAM_OUTPUT)) {
        #### si le fichier output existe
        list_out <- tl_inp_eo$PARAM_OUTPUT %>%
          pivot_longer(col = everything(), names_to = "name", values_to = "status") %>%
          filter(status == TRUE) %>%
          dplyr::select(name)
        list_out <- list_out[[1]]
        if (length(list_out) > 0) {
          ### si le fichier parametre contien quelque chose
          tl_csvtowrite2_sorted_names <- c(
            PARAM_NAME,
            list_base_file,
            list_out
          )
        } else {
          ### si le fichier parametre contien rien
          PARAM_NAME <- tl_csvtowrite2_sorted_names[grepl("^PARAM", tl_csvtowrite2_sorted_names)]

          tl_csvtowrite2_sorted_names <- c(
            PARAM_NAME,
            "EO_MASSNAHMEN_nom",
            "EO_MASSNAHMEN_real",
            "EO_FHH_nom",
            "EO_FHH_real"
          )
        }
      } else {
        #### si le fichier output n'existe pas
        PARAM_NAME <- tl_csvtowrite2_sorted_names[grepl("^PARAM", tl_csvtowrite2_sorted_names)]

        tl_csvtowrite2_sorted_names <- c(
          PARAM_NAME,
          list_base_file
        )
      }
    } else {
      ### si le parametre light_output est présent
      if (tl_inp_eo$PARAM_GLOBAL$light_output) {
        ### si le parametre light_output == TRUE
        if (!is.null(tl_inp_eo$PARAM_OUTPUT)) {
          list_out <- tl_inp_eo$PARAM_OUTPUT %>%
            pivot_longer(col = everything(), names_to = "name", values_to = "status") %>%
            filter(status == TRUE) %>%
            dplyr::select(name)
          list_out <- list_out[[1]]
          if (length(list_out) > 0) {
            PARAM_NAME <- tl_csvtowrite2_sorted_names[grepl("^PARAM", tl_csvtowrite2_sorted_names)]

            tl_csvtowrite2_sorted_names <- c(
              PARAM_NAME,
              list_base_file,
              list_out
            )
          } else {
            PARAM_NAME <- tl_csvtowrite2_sorted_names[grepl("^PARAM", tl_csvtowrite2_sorted_names)]

            tl_csvtowrite2_sorted_names <- c(
              PARAM_NAME,
              list_base_file
            )
          }
        } else {
          PARAM_NAME <- tl_csvtowrite2_sorted_names[grepl("^PARAM", tl_csvtowrite2_sorted_names)]

          tl_csvtowrite2_sorted_names <- c(
            PARAM_NAME,
            list_base_file
          )
        }
      } else {
        ### si le parametre light_output == FALSE
        tl_csvtowrite_out <- tl_csvtowrite
      }
    }

  tl_csvtowrite_out <- tl_csvtowrite2[tl_csvtowrite2_sorted_names] # sort names alphabetically

  tidylist_write(
    tl_csvtowrite_out,
    path_out_identifier
  )

  PARAM_ALL <-
    # Filtere die Namen der Dataframes, die mit "PARAM" beginnen
    tl_inp_eo[names(tl_inp_eo) %>% grep("^PARAM", ., value = TRUE)] %>%
      keep(~ nrow(.x) > 0) %>% # Behalte nur Dataframes mit mindestens einer Zeile
      imap(~ {
          df <- as.data.frame(.x) # Stelle sicher, dass jedes Element als Dataframe behandelt wird
          colnames(df) <- paste0(.y, ".", colnames(df)) # Füge Präfix mit dem Namen des Dataframes zu den Spaltennamen hinzu
          df # Gib den modifizierten Dataframe zurück
      }) %>%
      bind_cols() # Kombiniere alle Dataframes spaltenweise in einen einzigen Dataframe


  # write FHH diskontiert
  tl_inp_eo$PARAM_GLOBAL$diskontierung <- TRUE
  write_file_eo_fhh_flexible(
    PARAM_GLOBAL = tl_inp_eo$PARAM_GLOBAL,
    EO_FHH = tl_out_eo$EO_FHH_real,
    ECKWERTE_SCENARIO = tl_out_eo$ECKWERTE_SCENARIO,
    ECKWERTE_EXTENDED = tl_out_eo$ECKWERTE_EXTENDED,
    PARAM_ALL = PARAM_ALL,
    path_out_identifier = path_out_identifier,
    diskont = TRUE
  )

  # write FHH nominal
  tl_inp_eo$PARAM_GLOBAL$diskontierung <- FALSE
  write_file_eo_fhh_flexible(
    PARAM_GLOBAL = tl_inp_eo$PARAM_GLOBAL,
    EO_FHH = tl_out_eo$EO_FHH_nom,
    ECKWERTE_SCENARIO = tl_out_eo$ECKWERTE_SCENARIO,
    ECKWERTE_EXTENDED = tl_out_eo$ECKWERTE_EXTENDED,
    PARAM_ALL = PARAM_ALL,
    path_out_identifier = path_out_identifier,
    diskont = FALSE
  )


  if (tl_inp_eo$PARAM_GLOBAL$flag_param_eo_massn) {

    # Massnahmentabelle diskontiert
    tl_inp_eo$PARAM_GLOBAL$diskontierung <- TRUE
    tl_inp_eo$PARAM_GLOBAL$output_path <- as_tibble(path_out_identifier)
    mod_eo_output_massn_flexible(
      PARAM_GLOBAL = tl_inp_eo$PARAM_GLOBAL,
      EO_MASSNAHMEN = tl_out_eo$EO_MASSNAHMEN_real,
      PARAM_ALL = PARAM_ALL,
      ECKWERTE_SCENARIO = tl_out_eo$ECKWERTE_SCENARIO,
      AHV_LOHNSUMME = tl_out_eo$EO_FHH_real %>% dplyr::select(jahr,ahv_lohnsumme),
      PARAM_MASSNAHMEN_BASE = tl_inp_eo$PARAM_MASSNAHMEN_BASE
    )
    # Massnahmentabelle nominal
    tl_inp_eo$PARAM_GLOBAL$diskontierung <- FALSE
    tl_inp_eo$PARAM_GLOBAL$output_path <- as_tibble(path_out_identifier)
    mod_eo_output_massn_flexible(
      PARAM_GLOBAL = tl_inp_eo$PARAM_GLOBAL,
      EO_MASSNAHMEN = tl_out_eo$EO_MASSNAHMEN_nom,
      PARAM_ALL = PARAM_ALL,
      ECKWERTE_SCENARIO = tl_out_eo$ECKWERTE_SCENARIO,
    AHV_LOHNSUMME = tl_out_eo$EO_FHH_nom %>% dplyr::select(jahr,ahv_lohnsumme),
    PARAM_MASSNAHMEN_BASE = tl_inp_eo$PARAM_MASSNAHMEN_BASE
    )
  }
  # Store params

  copy_param(path=path_param, path_out_identifier, tl_inp=tl_inp_eo)

  return(path_out_identifier)
}

#' @title Output IV
#'
#' @description Speichert den IV Output
#'
#' @param path               - (Container)Pfad
#' @param path_out           - Ausgabepfad abweichend von Containerpfad
#' @param tl_inp             - Input-Daten
#' @param tl_out             - Output-Daten
#'
#' @return path_out_identifier  - path to output container
#'
#' @author [MAS BSV](mailto:sekretariat.mas@bsv.admin.ch)
#'
#' @export
mod_out_iv <- function(path_param, path_out, tl_out_iv) {

    print("Run module: mod_out_iv")

  # construct output path
  path_out_identifier <-
    path_out_resolve(path_out, tl_out_iv$PARAM_GLOBAL$identifier_number)

  tl_out_iv <- tl_out_iv[sort(names(tl_out_iv))]

  # write csv
  tidylist_write(
    c(tl_out_iv),
    path_out_identifier
  )

  PARAM_ALL <- tl_out_iv[
      # Filtere die Namen der Dataframes, die mit "PARAM" beginnen
      names(tl_out_iv) %>% grep("^PARAM", ., value = TRUE)
  ] %>%
      keep(~ nrow(.x) > 0) %>% # Behalte nur Dataframes mit mindestens einer Zeile
      imap(~ {
          df <- as.data.frame(.x) # Stelle sicher, dass jedes Element als Dataframe behandelt wird
          colnames(df) <- paste0(.y, ".", colnames(df)) # Füge Präfix mit dem Namen des Dataframes zu den Spaltennamen hinzu
          df # Gib den modifizierten Dataframe zurück
      }) %>%
      bind_cols() # Kombiniere alle Dataframes spaltenweise in einen einzigen Dataframe

  # En termes réels
  tl_out_iv$PARAM_GLOBAL$diskontierung <- TRUE

  write_file_iv_fhh_flexible(
    PARAM_GLOBAL = tl_out_iv$PARAM_GLOBAL,
    IV_FHH = tl_out_iv$IV_FHH,
    PARAM_ALL = PARAM_ALL,
    ECKWERTE = tl_out_iv$ECKWERTE,
    path_out_identifier = path_out_identifier
  )

  # En termes nominaux
  tl_out_iv$PARAM_GLOBAL$diskontierung <- FALSE

  write_file_iv_fhh_flexible(
    PARAM_GLOBAL = tl_out_iv$PARAM_GLOBAL,
    IV_FHH = tl_out_iv$IV_FHH_NOM,
    PARAM_ALL = PARAM_ALL,
    ECKWERTE = tl_out_iv$ECKWERTE,
    path_out_identifier = path_out_identifier
  )


    if(tl_out_iv$PARAM_GLOBAL$flag_param_massn){

        tl_out_iv$PARAM_GLOBAL$diskontierung <- TRUE
        tl_out_iv$PARAM_GLOBAL$output_path <- as_tibble(path_out_identifier)

       mod_iv_output_massn_flexible(
          PARAM_GLOBAL = tl_out_iv$PARAM_GLOBAL,
          DELTAS_EINN_AUSG = tl_out_iv$DELTAS_EINN_AUSG_REAL,
          PARAM_ALL = PARAM_ALL,
          ECKWERTE = tl_out_iv$ECKWERTE,
          PARAM_MASSNAHMEN_BASE = tl_out_iv$PARAM_MASSNAHMEN_BASE
      )

       tl_out_iv$PARAM_GLOBAL$diskontierung <- FALSE
       tl_out_iv$PARAM_GLOBAL$output_path <- as_tibble(path_out_identifier)

       mod_iv_output_massn_flexible(
         PARAM_GLOBAL = tl_out_iv$PARAM_GLOBAL,
         DELTAS_EINN_AUSG = tl_out_iv$DELTAS_EINN_AUSG_NOM,
         PARAM_ALL = PARAM_ALL,
         ECKWERTE = tl_out_iv$ECKWERTE,
         PARAM_MASSNAHMEN_BASE = tl_out_iv$PARAM_MASSNAHMEN_BASE
       )

    }

  if(!is.null(tl_out_iv$PARAM_GLOBAL$ausgaben_output)){
      if(tl_out_iv$PARAM_GLOBAL$ausgaben_output){
          tl_out_iv$PARAM_GLOBAL$diskontierung <- TRUE
          tl_out_iv$PARAM_GLOBAL$output_path <- as_tibble(path_out_identifier)

  mod_iv_output_ausgaben_table(
      PARAM_GLOBAL = tl_out_iv$PARAM_GLOBAL,
      IV_FHH = tl_out_iv$IV_FHH,
      PARAM_ALL = PARAM_ALL,
      ECKWERTE = tl_out_iv$ECKWERTE,
      path_out_identifier = path_out_identifier
  )


  tl_out_iv$PARAM_GLOBAL$diskontierung <- FALSE
  tl_out_iv$PARAM_GLOBAL$output_path <- as_tibble(path_out_identifier)

  mod_iv_output_ausgaben_table(
      PARAM_GLOBAL = tl_out_iv$PARAM_GLOBAL,
      IV_FHH = tl_out_iv$IV_FHH_NOM,
      PARAM_ALL = PARAM_ALL,
      ECKWERTE = tl_out_iv$ECKWERTE,
      path_out_identifier = path_out_identifier
  )
  }
  }
  # Store params
  copy_param(path_param, path_out_identifier, tl_inp=tl_out_iv)

  return(path_out_identifier)
}


mod_out_el <- function(path, path_out, tl_inp, tl_out_el) {

  # construct output path
  path_out_identifier <-
    path_out_resolve(path_out, tl_inp$PARAM_GLOBAL$identifier_number)

  # write csv
  names_el <- names(tl_out_el)
  names_el[which(names_el=="")]<-"delete"
  names(tl_out_el)<-names_el
  tl_out_el$delete <- as_tibble(tl_out_el$delete)

  tidylist_write(
    c(
      tl_out_el
    ),
    path_out_identifier
  )
  #
  ECKWERTE <- tl_inp$ECKWERTE
  PARAM_GLOBAL <- tl_inp$PARAM_GLOBAL
  PARAM_GLOBAL$diskontierung <- TRUE
  write_file_el_fhh_flexible(
    PARAM_GLOBAL = PARAM_GLOBAL,
    EL_AHV_FHH = tl_out_el$EL_ZU_AHV_BILANZ,
    EL_IV_FHH = tl_out_el$EL_ZU_IV_BILANZ,
    EL_TOT_FHH = tl_out_el$EL_TOT_BILANZ,
    ECKWERTE = ECKWERTE,
    path_out_identifier = path_out_identifier
  )
  ECKWERTE <- tl_inp$ECKWERTE
  PARAM_GLOBAL <- tl_inp$PARAM_GLOBAL
  PARAM_GLOBAL$diskontierung <- FALSE
  write_file_el_fhh_flexible(
    PARAM_GLOBAL = PARAM_GLOBAL,
    EL_AHV_FHH = tl_out_el$EL_ZU_AHV_BILANZ_NOM,
    EL_IV_FHH = tl_out_el$EL_ZU_IV_BILANZ_NOM,
    EL_TOT_FHH = tl_out_el$EL_TOT_BILANZ_NOM,
    ECKWERTE = ECKWERTE,
    path_out_identifier = path_out_identifier
  )



if (tl_inp$PARAM_GLOBAL$massnahmen_el) {


    PARAM_ALL <- tl_inp[
        # Filtere die Namen der Dataframes, die mit "PARAM" beginnen
        names(tl_inp) %>% grep("^PARAM", ., value = TRUE)
    ] %>%
        keep(~ nrow(.x) > 0) %>% # Behalte nur Dataframes mit mindestens einer Zeile
        imap(~ {
            df <- as.data.frame(.x) # Stelle sicher, dass jedes Element als Dataframe behandelt wird
            colnames(df) <- paste0(.y, ".", colnames(df)) # Füge Präfix mit dem Namen des Dataframes zu den Spaltennamen hinzu
            df # Gib den modifizierten Dataframe zurück
        }) %>%
        bind_cols() # Kombiniere alle Dataframes spaltenweise in einen einzigen Dataframe

     # write Massnahmentabelle diskontiert
     tl_inp$PARAM_GLOBAL$diskontierung <- TRUE
     tl_inp$PARAM_GLOBAL$output_path <- path_out_identifier
     mod_el_output_massn_flexible(
      PARAM_GLOBAL = tl_inp$PARAM_GLOBAL,
      EL_MASSNAHMEN_AHV = tl_out_el$MASS_TAB_AHV_REAL,
      EL_MASSNAHMEN_IV = tl_out_el$MASS_TAB_IV_REAL,
      EL_MASSNAHMEN_TOT = tl_out_el$MASS_TAB_TOT_REAL,
      ECKWERTE = ECKWERTE,
      # path_out_identifier = path_out_identifier
       PARAM_ALL = PARAM_ALL

     )
      # write Massnahmentabelle nominal
     tl_inp$PARAM_GLOBAL$diskontierung <- FALSE
     tl_inp$PARAM_GLOBAL$output_path <- path_out_identifier
     mod_el_output_massn_flexible(
         PARAM_GLOBAL = tl_inp$PARAM_GLOBAL,
         EL_MASSNAHMEN_AHV = tl_out_el$MASS_TAB_AHV,
         EL_MASSNAHMEN_IV = tl_out_el$MASS_TAB_IV,
         EL_MASSNAHMEN_TOT = tl_out_el$MASS_TAB_TOT,
         ECKWERTE = ECKWERTE,
         PARAM_ALL = PARAM_ALL
       )
    }

  # Store params
  copy_param(path, path_out_identifier, tl_inp)

  return(path_out_identifier)
}
