/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The SF licenses this file
 * to you 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.
 */
package org.apache.felix.hc.core.impl.monitor;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;

import org.apache.felix.hc.api.Result;
import org.apache.felix.hc.api.condition.Healthy;
import org.apache.felix.hc.api.condition.SystemReady;
import org.apache.felix.hc.api.condition.Unhealthy;
import org.apache.felix.hc.api.execution.HealthCheckExecutionResult;
import org.apache.felix.hc.api.execution.HealthCheckExecutor;
import org.apache.felix.hc.api.execution.HealthCheckSelector;
import org.apache.felix.hc.core.impl.executor.CombinedExecutionResult;
import org.apache.felix.hc.core.impl.executor.HealthCheckExecutorThreadPool;
import org.apache.felix.hc.core.impl.scheduling.AsyncIntervalJob;
import org.apache.felix.hc.core.impl.scheduling.AsyncJob;
import org.apache.felix.hc.core.impl.scheduling.CronJobFactory;
import org.apache.felix.hc.core.impl.util.lang.StringUtils;
import org.osgi.framework.BundleContext;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceRegistration;
import org.osgi.service.component.ComponentConstants;
import org.osgi.service.component.ComponentContext;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.ConfigurationPolicy;
import org.osgi.service.component.annotations.Deactivate;
import org.osgi.service.component.annotations.Reference;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventAdmin;
import org.osgi.service.metatype.annotations.AttributeDefinition;
import org.osgi.service.metatype.annotations.Designate;
import org.osgi.service.metatype.annotations.ObjectClassDefinition;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Monitors health check tags and/or names and depending on configuration:
 * <p>
 * <ul>
 * <li>Activates the condition marker services {@link SystemReady},
 * {@link Healthy}, {@link Unhealthy}</li>
 * <li>Sends OSGi events</li>
 * </ul>
 * <p>
 * 
 */
@Component(immediate = true, configurationPolicy = ConfigurationPolicy.REQUIRE)
@Designate(ocd = HealthCheckMonitor.Config.class, factory = true)
public class HealthCheckMonitor implements Runnable {
    private static final Logger LOG = LoggerFactory.getLogger(HealthCheckMonitor.class);

    public static final String TAG_SYSTEMREADY = "systemready";

    public static final String EVENT_TOPIC_PREFIX = "org/apache/felix/healthchange";
    public static final String EVENT_PROP_EXECUTION_RESULT = "executionResult";
    public static final String EVENT_PROP_STATUS = "status";
    public static final String EVENT_PROP_PREVIOUS_STATUS = "previousStatus";

    static final Healthy MARKER_SERVICE_HEALTHY = new Healthy() {
    };
    static final Unhealthy MARKER_SERVICE_UNHEALTHY = new Unhealthy() {
    };
    static final SystemReady MARKER_SERVICE_SYSTEMREADY = new SystemReady() {
    };

    @ObjectClassDefinition(name = "Health Check Monitor", description = "Regularly executes health checks according to given interval/cron expression")
    public @interface Config {

        @AttributeDefinition(name = "Tags", description = "List of tags to query regularly")
        String[] tags() default {};

        @AttributeDefinition(name = "Names", description = "List of health check names to query regularly")
        String[] names() default {};

        @AttributeDefinition(name = "Interval (Sec)", description = "Will execute the checks for give tags every n seconds (either use intervalInSec or cronExpression )")
        long intervalInSec() default 0;

        @AttributeDefinition(name = "Interval (Cron Expresson)", description = "Will execute the checks for give tags according to cron expression")
        String cronExpression() default "";

        @AttributeDefinition(name = "Register Healthy Marker Service", description = "For the case a given tag/name is healthy, will register a service Healthy with property tag=<tagname> (or name=<hc.name>) that other services can depend on")
        boolean registerHealthyMarkerService() default true;

        @AttributeDefinition(name = "Register Unhealthy Marker Service", description = "For the case a given tag/name is unhealthy, will register a service Unhealthy with property tag=<tagname> (or name=<hc.name>) that other services can depend on")
        boolean registerUnhealthyMarkerService() default false;

        @AttributeDefinition(name = "Treat WARN as Healthy", description = "Whether to treat status WARN as healthy (it normally should because WARN indicates a working system that only possibly might become unavailable if no action is taken")
        boolean treatWarnAsHealthy() default true;

        @AttributeDefinition(name = "Send Events", description = "Whether to send OSGi events for the case a status has changed")
        boolean sendEvents() default true;

        @AttributeDefinition
        String webconsole_configurationFactory_nameHint() default "Health Monitor for '{tags}'/'{names}', {intervalInSec}sec/{cronExpression}, Marker Service Healthy:{registerHealthyMarkerService} Unhealthy:{registerUnhealthyMarkerService}, Send Events {sendEvents}";
    }

    @Reference
    HealthCheckExecutor executor;
    
    @Reference
    HealthCheckExecutorThreadPool healthCheckExecutorThreadPool;

    @Reference
    CronJobFactory cronJobFactory;

    @Reference
    private EventAdmin eventAdmin;
    
    // component state
    AsyncJob monitorJob = null;
    List<String> tags;
    List<String> names;
    List<HealthState> healthStates = new ArrayList<>();

    private long intervalInSec;
    private String cronExpression;

    private boolean registerHealthyMarkerService;
    private boolean registerUnhealthyMarkerService;

    private boolean treatWarnAsHealthy;

    private boolean sendEvents;

    private BundleContext bundleContext;

    @Activate
    protected final void activate(BundleContext bundleContext, Config config, ComponentContext componentContext)
            throws InvalidSyntaxException {

        this.bundleContext = bundleContext;

        this.tags = Arrays.asList(config.tags());
        this.tags.stream().filter(StringUtils::isNotBlank).forEach(tag -> healthStates.add(new HealthState(tag, true)));

        this.names = Arrays.asList(config.names());
        this.names.stream().filter(StringUtils::isNotBlank)
                .forEach(name -> healthStates.add(new HealthState(name, false)));

        this.registerHealthyMarkerService = config.registerHealthyMarkerService();
        this.registerUnhealthyMarkerService = config.registerUnhealthyMarkerService();

        this.treatWarnAsHealthy = config.treatWarnAsHealthy();
        this.sendEvents = config.sendEvents();

        this.intervalInSec = config.intervalInSec();
        this.cronExpression = config.cronExpression();
        if (StringUtils.isNotBlank(cronExpression)) {
            try {
                monitorJob = cronJobFactory.getAsyncCronJob(this, "job-hc-monitor-" + componentContext.getProperties().get(ComponentConstants.COMPONENT_ID),
                        "healthcheck-monitor", cronExpression);
            } catch (UnsupportedOperationException e) {
                throw new IllegalArgumentException("Cannot use cron expression " + cronExpression
                        + " while class is not available: " + cronExpression);
            }
        } else if (intervalInSec > 0) {
            monitorJob = new AsyncIntervalJob(this, healthCheckExecutorThreadPool, intervalInSec);
        } else {
            throw new IllegalArgumentException("Either cronExpression or intervalInSec needs to be set");
        }
        monitorJob.schedule();
        LOG.info("HealthCheckMonitor active for tags {} and names {}", this.tags, this.names);
    }

    @Override
    public String toString() {
        return "[HealthCheckMonitor tags=" + tags + "/names=" + names + ", intervalInSec=" + intervalInSec + "/cron="
                + cronExpression + "]";
    }

    @Deactivate
    protected final void deactivate() {
        healthStates.stream().forEach(HealthState::cleanUp);
        healthStates.clear();
        monitorJob.unschedule();
        LOG.info("HealthCheckMonitor deactivated for tags {} and names {}", this.tags, this.names);
    }

    public void run() {
        try {
            // run in tags/names in parallel
            healthStates.parallelStream().forEach(healthState -> {
                HealthCheckSelector selector = healthState.isTag ? HealthCheckSelector.tags(healthState.tagOrName)
                        : HealthCheckSelector.names(healthState.tagOrName);

                List<HealthCheckExecutionResult> executionResults = executor.execute(selector);

                HealthCheckExecutionResult result = executionResults.size() == 1 ? executionResults.get(0)
                        : new CombinedExecutionResult(executionResults, Result.Status.TEMPORARILY_UNAVAILABLE);

                LOG.trace("Result of '{}' => {}", healthState.tagOrName, result.getHealthCheckResult().getStatus());

                healthState.update(result);
            });

            LOG.trace("HealthCheckMonitor: updated results for tags {} and names {}", this.tags, this.names);
        } catch (Exception e) {
            LOG.error("Exception HealthCheckMonitor run(): " + e, e);
        }

    }

    class HealthState {

        private String tagOrName;
        private boolean isTag;
        private String propertyName;

        private ServiceRegistration<?> healthyRegistration = null;
        private ServiceRegistration<Unhealthy> unhealthyRegistration = null;

        private Result.Status status = null;
        private boolean isHealthy = false;
        private boolean statusChanged = false;

        HealthState(String tagOrName, boolean isTag) {
            this.tagOrName = tagOrName;
            this.isTag = isTag;
            this.propertyName = isTag ? "tag" : "name";
        }

        @Override
        public String toString() {
            return "[HealthState tagOrName=" + tagOrName + ", isTag=" + isTag + ", status=" + status + ", isHealthy="
                    + isHealthy + ", statusChanged=" + statusChanged + "]";
        }

        synchronized void update(HealthCheckExecutionResult executionResult) {
            Result.Status previousStatus = status;
            status = executionResult.getHealthCheckResult().getStatus();

            isHealthy = (status == Result.Status.OK || (treatWarnAsHealthy && status == Result.Status.WARN));
            statusChanged = previousStatus != status;
            LOG.trace("  {}: isHealthy={} statusChanged={}", tagOrName, isHealthy, statusChanged);

            registerMarkerServices();
            sendEvent(executionResult, previousStatus);
        }

        private void registerMarkerServices() {
            if (registerHealthyMarkerService) {
                if (isHealthy && healthyRegistration == null) {
                    registerHealthyService();
                } else if (!isHealthy && healthyRegistration != null) {
                    unregisterHealthyService();
                }
            }
            if (registerUnhealthyMarkerService) {
                if (!isHealthy && unhealthyRegistration == null) {
                    registerUnhealthyService();
                } else if (isHealthy && unhealthyRegistration != null) {
                    unregisterUnhealthyService();
                }
            }
        }

        private void registerHealthyService() {
            if (healthyRegistration == null) {
                LOG.debug("HealthCheckMonitor: registerHealthyService() {} ", tagOrName);
                Dictionary<String, String> registrationProps = new Hashtable<>();
                registrationProps.put(propertyName, tagOrName);
                registrationProps.put("activated", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));

                if (TAG_SYSTEMREADY.equals(tagOrName)) {
                    LOG.debug("HealthCheckMonitor: SYSTEM READY");
                    healthyRegistration = bundleContext.registerService(
                            new String[] { SystemReady.class.getName(), Healthy.class.getName() },
                            MARKER_SERVICE_SYSTEMREADY, registrationProps);
                } else {
                    healthyRegistration = bundleContext.registerService(Healthy.class, MARKER_SERVICE_HEALTHY,
                            registrationProps);
                }
                LOG.debug("HealthCheckMonitor: Healthy service for {} '{}' registered", propertyName, tagOrName);
            }
        }

        private void unregisterHealthyService() {
            if (healthyRegistration != null) {
                healthyRegistration.unregister();
                healthyRegistration = null;
                LOG.debug("HealthCheckMonitor: Healthy service for {} '{}' unregistered", propertyName, tagOrName);
            }
        }

        private void registerUnhealthyService() {
            if (unhealthyRegistration == null) {
                Dictionary<String, String> registrationProps = new Hashtable<>();
                registrationProps.put("tag", tagOrName);
                registrationProps.put("activated", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
                unhealthyRegistration = bundleContext.registerService(Unhealthy.class, MARKER_SERVICE_UNHEALTHY,
                        registrationProps);
                LOG.debug("HealthCheckMonitor: Unhealthy service for {} '{}' registered", propertyName, tagOrName);
            }
        }

        private void unregisterUnhealthyService() {
            if (unhealthyRegistration != null) {
                unhealthyRegistration.unregister();
                unhealthyRegistration = null;
                LOG.debug("HealthCheckMonitor: Unhealthy service for {} '{}' unregistered", propertyName, tagOrName);
            }
        }

        private void sendEvent(HealthCheckExecutionResult executionResult, Result.Status previousStatus) {
            if (sendEvents && statusChanged) {
                Map<String, Object> properties = new HashMap<>();
                properties.put(EVENT_PROP_STATUS, status);
                if (previousStatus != null) {
                    properties.put(EVENT_PROP_PREVIOUS_STATUS, previousStatus);
                }
                properties.put(EVENT_PROP_EXECUTION_RESULT, executionResult);
                String topic = EVENT_TOPIC_PREFIX + "/" + propertyName + "/" + tagOrName.replaceAll("\\s+", "_");
                eventAdmin.postEvent(new Event(topic, properties));
                LOG.debug("HealthCheckMonitor: Posted event for topic '{}': Status change from {} to {}", topic,
                        previousStatus, status);
                if (!(executionResult instanceof CombinedExecutionResult)) {
                    String componentName = (String) executionResult.getHealthCheckMetadata().getServiceReference()
                            .getProperty(ComponentConstants.COMPONENT_NAME);
                    if (StringUtils.isNotBlank(componentName)) {
                        String topicClass = EVENT_TOPIC_PREFIX + "/component/" + componentName.replace(".", "/");
                        eventAdmin.postEvent(new Event(topicClass, properties));
                        LOG.debug("HealthCheckMonitor: Posted event for topic '{}': Status change from {} to {}",
                                topicClass, previousStatus, status);
                    }
                }
            }
        }

        synchronized void cleanUp() {
            unregisterHealthyService();
            unregisterUnhealthyService();
        }

    }
}