/*
 * **** BEGIN LICENSE BLOCK *****
 *  Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 *  The contents of this file are subject to the Mozilla Public License Version
 *  1.1 (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.mozilla.org/MPL/
 *
 *  Software distributed under the License is distributed on an "AS IS" basis,
 *  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 *  for the specific language governing rights and limitations under the
 *  License.
 *
 *  The Original Code is part of dcm4che, an implementation of DICOM(TM) in
 *  Java(TM), hosted at https://github.com/gunterze/dcm4che.
 *
 *  The Initial Developer of the Original Code is
 *  Agfa Healthcare.
 *  Portions created by the Initial Developer are Copyright (C) 2014
 *  the Initial Developer. All Rights Reserved.
 *
 *  Contributor(s):
 *  See @authors listed below
 *
 *  Alternatively, the contents of this file may be used under the terms of
 *  either the GNU General Public License Version 2 or later (the "GPL"), or
 *  the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 *  in which case the provisions of the GPL or the LGPL are applicable instead
 *  of those above. If you wish to allow use of your version of this file only
 *  under the terms of either the GPL or the LGPL, and not to allow others to
 *  use your version of this file under the terms of the MPL, indicate your
 *  decision by deleting the provisions above and replace them with the notice
 *  and other provisions required by the GPL or the LGPL. If you do not delete
 *  the provisions above, a recipient may use your version of this file under
 *  the terms of any one of the MPL, the GPL or the LGPL.
 *
 *  ***** END LICENSE BLOCK *****
 */
package org.dcm4che3.conf.dicom;

import org.dcm4che3.audit.EventID;
import org.dcm4che3.audit.EventTypeCode;
import org.dcm4che3.audit.ObjectFactory;
import org.dcm4che3.audit.RoleIDCode;
import org.dcm4che3.conf.api.*;
import org.dcm4che3.conf.api.internal.DicomConfigurationManager;
import org.dcm4che3.conf.core.DefaultBeanVitalizer;
import org.dcm4che3.conf.core.DefaultTypeSafeConfiguration;
import org.dcm4che3.conf.core.Nodes;
import org.dcm4che3.conf.core.adapters.NullToNullDecorator;
import org.dcm4che3.conf.core.api.BatchRunner.Batch;
import org.dcm4che3.conf.core.api.Configuration;
import org.dcm4che3.conf.core.api.ConfigurationException;
import org.dcm4che3.conf.core.api.TypeSafeConfiguration;
import org.dcm4che3.conf.core.api.internal.BeanVitalizer;
import org.dcm4che3.conf.core.context.LoadingContext;
import org.dcm4che3.conf.dicom.adapters.*;
import org.dcm4che3.data.Code;
import org.dcm4che3.data.Issuer;
import org.dcm4che3.data.ValueSelector;
import org.dcm4che3.net.ApplicationEntity;
import org.dcm4che3.net.Device;
import org.dcm4che3.net.DeviceInfo;
import org.dcm4che3.util.AttributesFormat;
import org.dcm4che3.util.Property;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;

/**
 * @author Roman K
 */
@SuppressWarnings("unchecked")
public class CommonDicomConfiguration implements DicomConfigurationManager, TransferCapabilityConfigExtension {

    private static final Logger log = LoggerFactory.getLogger(CommonDicomConfiguration.class);


    /**
     * see preventDeviceModifications(org.dcm4che3.net.Device)
     */
    private final Map<Device, Object> readOnlyDevices = Collections.synchronizedMap(new WeakHashMap<Device, Object>());

    protected final Configuration lowLevelConfig;
    private final BeanVitalizer vitalizer;

    private final Map<Class, List<Class>> extensionsByClass;
    private final TypeSafeConfiguration<DicomConfigurationRoot> config;
    private AlternativeTCLoader alternativeTCLoader;

    public CommonDicomConfiguration(Configuration configurationStorage, Map<Class, List<Class>> extensionsByClass, boolean doCacheTCGroups) {
        this(configurationStorage, extensionsByClass);
        alternativeTCLoader = new AlternativeTCLoader(this, doCacheTCGroups);
    }

    public CommonDicomConfiguration(Configuration configStorage, Map<Class, List<Class>> extensionsByClass) {

        config = new DefaultTypeSafeConfiguration<DicomConfigurationRoot>(
                configStorage,
                DicomConfigurationRoot.class,
                extensionsByClass
        );

        this.lowLevelConfig = configStorage;
        this.extensionsByClass = extensionsByClass;

        vitalizer = config.getVitalizer();

        addCustomAdapters(vitalizer);

        // quick init
        try {
            if (!configurationExists()) {
                lowLevelConfig.persistNode(DicomPath.CONFIG_ROOT_PATH, createInitialConfigRootNode(), null);

            }
        } catch (ConfigurationException e) {
            throw new RuntimeException("Dicom configuration cannot be initialized", e);
        }

        alternativeTCLoader = new AlternativeTCLoader(this, false);
    }

    /**
     * Returns a list of registered extensions for a specified base extension class
     *
     * @param clazz
     * @param <T>
     * @return
     */
    @Override
    public <T> List<Class<? extends T>> getExtensionClassesByBaseClass(Class<T> clazz) {
        List<Class> classes = extensionsByClass.get(clazz);

        List<Class<? extends T>> list = new ArrayList<Class<? extends T>>();

        if (classes != null)
            for (Class<?> aClass : classes) list.add((Class<? extends T>) aClass);

        return list;
    }

    public static void addCustomAdapters(BeanVitalizer defaultBeanVitalizer) {

        // register DICOM type adapters
        defaultBeanVitalizer.registerCustomConfigTypeAdapter(AttributesFormat.class, new NullToNullDecorator(new AttributeFormatTypeAdapter()));
        defaultBeanVitalizer.registerCustomConfigTypeAdapter(Code.class, new NullToNullDecorator(new CodeTypeAdapter()));
        defaultBeanVitalizer.registerCustomConfigTypeAdapter(Issuer.class, new NullToNullDecorator(new IssuerTypeAdapter()));
        defaultBeanVitalizer.registerCustomConfigTypeAdapter(ValueSelector.class, new NullToNullDecorator(new ValueSelectorTypeAdapter()));
        defaultBeanVitalizer.registerCustomConfigTypeAdapter(Property.class, new NullToNullDecorator(new PropertyTypeAdapter()));

        // register audit log type adapters
        defaultBeanVitalizer.registerCustomConfigTypeAdapter(EventTypeCode.class, new NullToNullDecorator(new AuditSimpleTypeAdapters.EventTypeCodeAdapter()));
        defaultBeanVitalizer.registerCustomConfigTypeAdapter(EventID.class, new NullToNullDecorator(new AuditSimpleTypeAdapters.EventIDTypeAdapter()));
        defaultBeanVitalizer.registerCustomConfigTypeAdapter(RoleIDCode.class, new NullToNullDecorator(new AuditSimpleTypeAdapters.RoleIDCodeTypeAdapter()));
    }

    protected HashMap<String, Object> createInitialConfigRootNode() {
        HashMap<String, Object> rootNode = new HashMap<String, Object>();
        rootNode.put("dicomDevicesRoot", new HashMap<String, Object>());

        List<Object> pathItems = new ArrayList<Object>(METADATA_ROOT_PATH.getPathItems());
        pathItems.remove(0);

        Nodes.replaceNode(rootNode, new HashMap(), pathItems);
        return rootNode;
    }

    @Override
    public TypeSafeConfiguration<DicomConfigurationRoot> getTypeSafeConfiguration() {
        return config;
    }

    @Override
    public boolean configurationExists() throws ConfigurationException {
        return lowLevelConfig.nodeExists(DicomPath.CONFIG_ROOT_PATH);
    }

    @Override
    public boolean purgeConfiguration() throws ConfigurationException {
        if (!configurationExists()) return false;
        lowLevelConfig.persistNode(DicomPath.CONFIG_ROOT_PATH, new HashMap<String, Object>(), null);
        return true;
    }

    @Override
    public void preventDeviceModifications(Device d) {
        readOnlyDevices.put(d, true);
    }

    @Override
    public void refreshTCGroups() {
        alternativeTCLoader.refreshTCGroups();
    }

    @Override
    public boolean registerAETitle(String aet) throws ConfigurationException {
        return true;
    }

    @Override
    public void unregisterAETitle(String aet) throws ConfigurationException {
    }


    @Override
    public ApplicationEntity findApplicationEntity(String aet) throws ConfigurationException {

        if (aet == null) throw new IllegalArgumentException("Requested AE's title cannot be null");

        Iterator<?> search = lowLevelConfig.search(DicomPath.DeviceNameByAEName.set("aeName", aet).path());

        if (!search.hasNext()) {
            search = lowLevelConfig.search(DicomPath.DeviceNameByAENameAlias.set("aeNameAlias", aet).path());

            if (!search.hasNext())
                throw new ConfigurationNotFoundException("AE '" + aet + "' not found");
        }

        String deviceNameNode = (String) search.next();
        if (search.hasNext())
            log.warn("Application entity title '{}' is not unique. Check the configuration!", aet);
        Device device = findDevice(deviceNameNode);

        ApplicationEntity ae = device.getApplicationEntity(aet);
        if (ae == null)
            throw new NoSuchElementException("Unexpected error");
        return ae;

    }

    @Override
    public ApplicationEntity findApplicationEntityByUUID(String uuid) throws ConfigurationException {

        if (uuid == null) throw new IllegalArgumentException("Requested AE's uuid cannot be null");

        Iterator search = lowLevelConfig.search(DicomPath.DeviceNameByAEUUID.set("aeUUID", uuid).path());

        try {
            String deviceNameNode = (String) search.next();
            Device device = findDevice(deviceNameNode);

            for (ApplicationEntity applicationEntity : device.getApplicationEntities()) {
                if (uuid.equals(applicationEntity.getUuid())) {
                    return applicationEntity;
                }
            }

            throw new NoSuchElementException("Unexpected error");

        } catch (NoSuchElementException e) {
            throw new ConfigurationNotFoundException("AE with UUID '" + uuid + "' not found", e);
        }
    }

    @Override
    public Device findDeviceByUUID(String uuid) throws ConfigurationException {
        if (uuid == null) throw new IllegalArgumentException("Requested Device's uuid cannot be null");

        Iterator search = lowLevelConfig.search(DicomPath.DeviceNameByUUID.set("deviceUUID", uuid).path());

        try {
            String deviceNameNode = (String) search.next();
            return findDevice(deviceNameNode);
        } catch (NoSuchElementException e) {
            throw new ConfigurationNotFoundException("Device with UUID '" + uuid + "' not found", e);
        }
    }

    @Override
    public Device findDevice(String name, DicomConfigOptions options) throws ConfigurationException {

        options = options == null ? new DicomConfigOptions() : options;

        if (name == null) throw new IllegalArgumentException("Requested device name cannot be null");

        try {
            Object deviceConfigurationNode = lowLevelConfig.getConfigurationNode(DicomPath.devicePath(name), Device.class);
            if (deviceConfigurationNode == null)
                throw new ConfigurationNotFoundException("Device " + name + " not found");

            LoadingContext ctx = config.getContextFactory().newLoadingContext();
            if (options.getIgnoreUnresolvedReferences() == Boolean.TRUE) {
                ctx.setIgnoreUnresolvedReferences(true);
            }

            Device device = vitalizer.newConfiguredInstance((Map<String, Object>) deviceConfigurationNode, Device.class, ctx);

            // perform alternative TC init in case an extension is present
            alternativeTCLoader.initGroupBasedTCs(device);

            return device;
        } catch (ConfigurationNotFoundException e) {
            throw e;
        } catch (RuntimeException e) {
            throw new ConfigurationException("Configuration for device " + name + " cannot be loaded", e);
        }

    }

    @Override
    public Device findDevice(String name) throws ConfigurationException {
        return findDevice(name, null);
    }

    @Override
    public DeviceInfo[] listDeviceInfos(DeviceInfo keys) throws ConfigurationException {
        throw new RuntimeException("Not yet implemented");
    }

    @Override
    public String[] listDeviceNames() throws ConfigurationException {
        Iterator search = lowLevelConfig.search(DicomPath.AllDeviceNames.path());
        List<String> deviceNames = null;
        try {
            deviceNames = new ArrayList<String>();
            while (search.hasNext())
                deviceNames.add((String) search.next());
        } catch (Exception e) {
            throw new ConfigurationException("Error while getting list of device names", e);
        }
        return deviceNames.toArray(new String[deviceNames.size()]);
    }

    @Override
    public List<String> listAllAETitles() throws ConfigurationException {
        List<String> aeNames = new ArrayList<String>();
        try {
            Iterator search = lowLevelConfig.search(DicomPath.AllAETitles.path());
            while (search.hasNext())
                aeNames.add((String) search.next());
        } catch (Exception e) {
            throw new ConfigurationException("Error while getting the list of registered AE titles", e);
        }
        return aeNames;
    }

    @Override
    public void persist(Device device) throws ConfigurationException {

        if (readOnlyDevices.containsKey(device)) handleReadOnlyDeviceModification();

        if (device.getDeviceName() == null) throw new ConfigurationException("The name of the device must not be null");
        if (lowLevelConfig.nodeExists(DicomPath.devicePath(device.getDeviceName())))
            throw new ConfigurationAlreadyExistsException("Device " + device.getDeviceName() + " already exists");
        // otherwise it is the same as merge
        merge(device);
    }

    private void handleReadOnlyDeviceModification() {

        String message = "Persisting the config for a Device object that is marked as read-only. " +
                "This warning is not affecting the behavior for now, but soon it will be replaced with throwing an exception!" +
                "If you want to make config modifications, use a separate instance of Device! See CSP configuration docs for details.";

        // create exception to log the stacktrace
        ConfigurationException exception = new ConfigurationException();

        log.warn(message, exception);
    }

    @Override
    public void merge(Device device) throws ConfigurationException {

        if (readOnlyDevices.containsKey(device)) handleReadOnlyDeviceModification();

        if (device.getDeviceName() == null) throw new ConfigurationException("The name of the device must not be null");
        Map<String, Object> configNode = createDeviceConfigNode(device);
        lowLevelConfig.persistNode(DicomPath.devicePath(device.getDeviceName()), configNode, Device.class);
    }

    protected Map<String, Object> createDeviceConfigNode(Device device) throws ConfigurationException {

        final Map<String, Object> deviceConfigNode = vitalizer.createConfigNodeFromInstance(device, Device.class);

        // wipe out TCs in case an extension is present
        alternativeTCLoader.cleanUpTransferCapabilitiesInDeviceNode(device, deviceConfigNode);


        return deviceConfigNode;
    }

    @Override
    public void removeDevice(String name) throws ConfigurationException {
        lowLevelConfig.removeNode(DicomPath.devicePath(name));
    }


    @Override
    public void close() {

    }

    @Override
    public void sync() throws ConfigurationException {
        lowLevelConfig.refreshNode(DicomPath.CONFIG_ROOT_PATH);
    }

    @Override
    public <T> T getDicomConfigurationExtension(Class<T> clazz) {

        // trick CDI
        if (TransferCapabilityConfigExtension.class.equals(clazz)) {
            return (T) new TransferCapabilityConfigExtension() {
                @Override
                public void persistTransferCapabilityConfig(TCConfiguration tcConfig) throws ConfigurationException {
                    CommonDicomConfiguration.this.persistTransferCapabilityConfig(tcConfig);
                }

                @Override
                public TCConfiguration getTransferCapabilityConfig() throws ConfigurationException {
                    return CommonDicomConfiguration.this.getTransferCapabilityConfig();
                }
            };
        }

        if (!clazz.isAssignableFrom(this.getClass())) {
            throw new IllegalArgumentException("Cannot find a configuration extension for class " + clazz.getName());
        }

        return (T) this;
    }

    @Override
    public BeanVitalizer getVitalizer() {
        return vitalizer;
    }


    @Override
    public Configuration getConfigurationStorage() {
        return lowLevelConfig;
    }

    @Override
    public void persistTransferCapabilityConfig(TCConfiguration tcConfig) throws ConfigurationException {
        Map<String, Object> configNode = vitalizer.createConfigNodeFromInstance(tcConfig);
        lowLevelConfig.persistNode(DicomPath.TC_GROUPS_PATH, configNode, TCConfiguration.class);
    }

    @Override
    public TCConfiguration getTransferCapabilityConfig() throws ConfigurationException {
        Map<String, Object> configurationNode = (Map<String, Object>) lowLevelConfig.getConfigurationNode(DicomPath.TC_GROUPS_PATH, TCConfiguration.class);

        if (configurationNode == null)
            return new TCConfiguration();

        return vitalizer.newConfiguredInstance(
                configurationNode,
                TCConfiguration.class);
    }

    @Override
    public void runBatch(final DicomConfigBatch dicomConfigBatch) {
        /*
         * Use the batch support of underlying configuration storage to execute batch
         */
        lowLevelConfig.runBatch(new Batch() {

            @Override
            public void run() {
                dicomConfigBatch.run();
            }

        });
    }

    public static BeanVitalizer createDefaultDicomVitalizer() {
        DefaultBeanVitalizer defaultBeanVitalizer = new DefaultBeanVitalizer();
        addCustomAdapters(defaultBeanVitalizer);
        return defaultBeanVitalizer;
    }
}