/*
// Copyright (c) 2018-2019 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
*/

#ifndef THIRD_PARTY_GBMCWEB_REDFISH_CORE_INCLUDE_REDFISH_H_
#define THIRD_PARTY_GBMCWEB_REDFISH_CORE_INCLUDE_REDFISH_H_

#include "bmcweb_config.h"
#include "app.hpp"
#include "managed_store_http.hpp"
#include "request_stats_store_http.hpp"
#include "aggregation_service.hpp"  // NOLINT
#include "assembly.hpp"             // NOLINT
#include "bios.hpp"
#include "cable.hpp"
#include "certificate_service.hpp"
#include "chassis.hpp"
#include "component_integrity.hpp"
#include "control.hpp"
#include "environment_metrics.hpp"
#include "ethernet.hpp"
#include "event_service.hpp"
#include "external_storer.hpp"
#include "fabric_adapters.hpp"
#include "fan.hpp"
#include "log_services.hpp"
#include "manager_diagnostic_data.hpp"
#include "managers.hpp"
#include "memory.hpp"
#include "message_registries.hpp"
#include "metric_report.hpp"
#include "metric_report_definition.hpp"
#include "network_adapter.hpp"
#include "network_protocol.hpp"
#include "redfish-core/lib/nvme_features.hpp"
#include "pcie.hpp"
#include "pcie_slots.hpp"
#include "port_metrics.hpp"
#include "ports.hpp"
#include "power.hpp"
#include "power_subsystem.hpp"
#include "power_supply.hpp"
#include "power_supply_metrics.hpp"
#include "processor.hpp"
#include "redfish_sessions.hpp"
#include "redfish_v1.hpp"
#include "sensors.hpp"
#include "service_root.hpp"
#include "storage.hpp"
#include "systems.hpp"
#include "task.hpp"
#include "telemetry_service.hpp"
#include "thermal.hpp"
#include "thermal_subsystem.hpp"
#include "trigger.hpp"
#include "trusted_component.hpp"
#include "update_service.hpp"

namespace redfish {
/*
 * @brief Top level class installing and providing Redfish services
 */
class RedfishService {
 public:
  /*
   * @brief Redfish service constructor
   *
   * Loads Redfish configuration and installs schema resources
   *
   * @param[in] app   Crow app on which Redfish will initialize
   */
  explicit RedfishService(App& app) {
#ifdef BMCWEB_ENABLE_REDFISH_AGGREGATION
    requestRoutesAggregationService(app);
    requestRoutesAggregationSourceCollection(app);
    requestRoutesAggregationSource(app);
#endif
    requestRoutesServiceRoot(app);
    requestRoutesNetworkProtocol(app);
    requestRoutesSession(app);
    requestEthernetInterfacesRoutes(app);
    requestPortsRoutes(app);
    requestPortMetricsRoutes(app);
#ifdef BMCWEB_ALLOW_DEPRECATED_POWER_THERMAL
    requestRoutesThermal(app);
    requestRoutesPower(app);
#endif
#ifdef BMCWEB_NEW_POWERSUBSYSTEM_THERMALSUBSYSTEM
    requestRoutesEnvironmentMetrics(app);
    requestRoutesPowerSubsystem(app);
    requestRoutesPowerSupply(app);
    requestRoutesPowerSupplyCollection(app);
    requestRoutesPowerSupplyMetrics(app);
    requestRoutesThermalSubsystem(app);
    requestRoutesFan(app);
    requestRoutesFanCollection(app);
#endif
    requestRoutesComponentIntegrityCollection(app);
    requestRoutesComponentIntegrity(app);
    requestRoutesComponentIntegritySPDMGetSignedMeasurementsAction(app);
    requestRoutesComponentIntegritySPDMGetSignedMeasurementsActionInfo(app);
    requestRoutesManagerCollection(app);
    requestRoutesManager(app);
    requestRoutesManagerResetAction(app);
    requestRoutesManagerResetActionInfo(app);
    requestRoutesManagerResetToDefaultsAction(app);
    requestRoutesManagerDiagnosticData(app);
    requestRoutesPCIeSlots(app);
    requestRoutesChassisCollection(app);
    requestRoutesChassis(app);
    requestRoutesChassisResetAction(app);
    requestRoutesChassisResetActionInfo(app);
    requestRoutesChassisAssembly(app);
    requestRoutesControl(app);
    requestRoutesChassisNetworkAdapterCollection(app);
    requestRoutesChassisNetworkAdapter(app);
    requestRoutesNetworkPortCollection(app);
    requestRoutesNetworkPort(app);
    requestRoutesNetworkPortMetrics(app);
    requestRoutesChassisDrive(app);
    requestRoutesChassisDriveName(app);
    requestRoutesTrustedComponentCollection(app);
    requestRoutesTrustedComponent(app);
    requestRoutesUpdateService(app);
    requestRoutesStorageCollection(app);
    requestRoutesStorage(app);
    requestRoutesStorageControllerCollection(app);
    requestRoutesStorageController(app);
    requestRoutesStorageControllerActions(app);
    requestRoutesStorageVolumeCollection(app);
    requestRoutesStorageVolume(app);
    requestRoutesNvmeFeatures(app);
    requestRoutesCable(app);
    requestRoutesCableCollection(app);
    requestDriveResetAction(app);
    requestRoutesDriveResetActionInfo(app);
    requestRoutesStorageControllerMetric(app);
    requestRoutesStorageVolumeMetric(app);
#ifdef BMCWEB_INSECURE_ENABLE_REDFISH_FW_TFTP_UPDATE
    requestRoutesUpdateServiceActionsSimpleUpdate(app);
#endif
    requestRoutesSoftwareInventoryCollection(app);
    requestRoutesSoftwareInventory(app);

    requestRoutesSystemLogServiceCollection(app);
    requestRoutesEventLogService(app);
    requestRoutesPostCodesEntryAdditionalData(app);

    requestRoutesPostCodesLogService(app);
    requestRoutesPostCodesClear(app);
    requestRoutesPostCodesEntry(app);
    requestRoutesPostCodesEntryCollection(app);

#ifdef BMCWEB_ENABLE_REDFISH_BOOT_TIME_LOG
    requestRoutesBootTimeLogService(app);
    requestRoutesBootTimeLogEntryCollection(app);
    requestRoutesBootTimeLogEntry(app);
#endif

#ifdef BMCWEB_ENABLE_REDFISH_DUMP_LOG
    requestRoutesSystemDumpService(app);
    requestRoutesSystemDumpEntryCollection(app);
    requestRoutesSystemDumpEntry(app);
    requestRoutesSystemDumpCreate(app);
    requestRoutesSystemDumpClear(app);

    requestRoutesBMCDumpService(app);
    requestRoutesBMCDumpEntryCollection(app);
    requestRoutesBMCDumpEntry(app);
    requestRoutesBMCDumpEntryDownload(app);
    requestRoutesBMCDumpCreate(app);
    requestRoutesBMCDumpClear(app);

    requestRoutesFaultLogDumpService(app);
    requestRoutesFaultLogDumpEntryCollection(app);
    requestRoutesFaultLogDumpEntry(app);
    requestRoutesFaultLogDumpClear(app);
#endif

#ifndef BMCWEB_ENABLE_REDFISH_DBUS_LOG_ENTRIES
    requestRoutesJournalEventLogEntryCollection(app);
    requestRoutesJournalEventLogEntry(app);
    requestRoutesJournalEventLogClear(app);
#endif

    requestRoutesBMCLogServiceCollection(app);
#ifdef BMCWEB_ENABLE_REDFISH_BMC_JOURNAL
    requestRoutesBMCJournalLogService(app);
    requestRoutesBMCJournalLogEntryCollection(app);
    requestRoutesBMCJournalLogEntry(app);
#endif

#ifdef BMCWEB_ENABLE_RASMANAGER_EVENT_LOG
    requestRoutesRasManagerLogService(app);
    requestRoutesRasManagerLogEntryCollection(app);
    requestRoutesRasManagerLogEntry(app);
    requestRoutesRasManagerLogClear(app);
#endif

#ifdef BMCWEB_ENABLE_ILIAD_EVENT_LOG
    requestRoutesIliadLogService(app);
    requestRoutesIliadLogEntryCollection(app);
    requestRoutesIliadLogEntry(app);
#endif

#ifdef BMCWEB_ENABLE_REDFISH_CPU_LOG
    requestRoutesCrashdumpService(app);
    requestRoutesCrashdumpEntryCollection(app);
    requestRoutesCrashdumpEntry(app);
    requestRoutesCrashdumpFile(app);
    requestRoutesCrashdumpClear(app);
    requestRoutesCrashdumpCollect(app);
#endif  // BMCWEB_ENABLE_REDFISH_CPU_LOG

#ifdef BMCWEB_ENABLE_PPR
    requestRoutesPPRService(app);
    requestRoutesPPRStatus(app);
    requestRoutesPPRFile(app);
    requestRoutesPPRConfig(app);
#endif  // BMCWEB_ENABLE_PPR

    requestRoutesProcessorCollection(app);
    requestRoutesProcessor(app);
    requestRoutesOperatingConfigCollection(app);
    requestRoutesOperatingConfig(app);
    requestRoutesMemoryCollection(app);
    requestRoutesMemory(app);
    requestRoutesMemoryMetrics(app);
    requestRoutesSubProcessorCoreCollection(app);
    requestRoutesSubProcessorCore(app);
    requestRoutesSubProcessorThreadCollection(app);
    requestRoutesSubProcessorThread(app);

    requestRoutesSystemsCollection(app);
    requestRoutesSystems(app);
    requestRoutesSystemActionsReset(app);
    requestRoutesSystemResetActionInfo(app);
    if constexpr (enableGoogleBaremetal) {
      requestRoutesSystemBootGuestOS(app);
      requestRoutesSystemBootGuestOSInfo(app);
    }
    requestRoutesBiosService(app);
    requestRoutesBiosReset(app);

#ifdef BMCWEB_ENABLE_REDFISH_DBUS_LOG_ENTRIES
    requestRoutesDBusLogServiceActionsClear(app);
    requestRoutesDBusEventLogEntryCollection(app);
    requestRoutesDBusEventLogEntry(app);
    requestRoutesDBusEventLogEntryDownload(app);
#endif

#ifdef BMCWEB_ENABLE_REDFISH_HOST_LOGGER
    requestRoutesSystemHostLogger(app);
    requestRoutesSystemHostLoggerCollection(app);
    requestRoutesSystemHostLoggerLogEntry(app);
#endif

#ifdef HEALTH_POPULATE
    requestRoutesHealthMonitorLogService(app);
    requestRoutesHealthMonitorLogEntryCollection(app);
    requestRoutesHealthMonitorLogEntry(app);
#endif /* HEALTH_POPULATE */

    requestRoutesMessageRegistryFileCollection(app);
    requestRoutesMessageRegistryFile(app);
    requestRoutesMessageRegistry(app);

    requestRoutesCertificateService(app);
    requestRoutesHTTPSCertificate(app);
    requestRoutesTrustStoreCertificate(app);
    requestRoutesChassisCertificate(app);

    requestRoutesSystemPCIeFunctionCollection(app);
    requestRoutesSystemPCIeFunction(app);
    requestRoutesSystemPCIeDeviceCollection(app);
    requestRoutesSystemPCIeDevice(app);

    requestRoutesSensorCollection(app);
    requestRoutesSensor(app);

    requestRoutesTaskMonitor(app);
    requestRoutesTaskService(app);
    requestRoutesTaskCollection(app);
    requestRoutesTask(app);

    // Event service is not used and not tested by Google.
    // We advertise that this service is disabled.
    requestRoutesEventService(app);
    // requestRoutesEventDestinationCollection(app);
    // requestRoutesEventDestination(app);

    requestRoutesFabricAdapters(app);
    requestRoutesFabricAdapterCollection(app);
    requestRoutesSubmitTestEvent(app);

    requestRoutesTelemetryService(app);
    requestRoutesMetricReportDefinitionCollection(app);
    requestRoutesMetricReportDefinition(app);
    requestRoutesMetricReportCollection(app);
    requestRoutesMetricReport(app);
    requestRoutesTriggerCollection(app);
    requestRoutesTrigger(app);

    requestRoutesManagerFanModeChangeActionInfo(app);
    requestRoutesManagerFanModeChangeAction(app);

    requestRoutesPsiMetrics(app);
    requestRoutesManagersCertificates(app);

#ifdef BMCWEB_ENABLE_REDFISH_EXTERNAL_STORER
    requestRoutesExternalStorer(app);
    requestRoutesProcessorMetricsViaExternalStorer(app);
#endif

    requestRoutesHostBootTime(app);
    requestRoutesBmcBootTime(app);

    // Stateful BMC - managed store:
    managedStore::requestRoutesManagedStore(app);
    // request stats exporting
    managedStore::requestRoutesRequestStatsStore(app);

    // Note, this must be the last route registered
    requestRoutesRedfish(app);
  }
};

}  // namespace redfish

#endif  // THIRD_PARTY_GBMCWEB_REDFISH_CORE_INCLUDE_REDFISH_H_