package org.opendaylight.controller.forwardingrulesmanager.consumer.impl;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.opendaylight.controller.clustering.services.IClusterContainerServices;
import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler;
import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction;
import org.opendaylight.controller.md.sal.common.api.data.DataModification;
import org.opendaylight.controller.sal.common.util.Rpcs;
import org.opendaylight.controller.sal.core.IContainer;
import org.opendaylight.controller.sal.utils.ServiceHelper;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.sal.utils.StatusCode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.config.rev131024.Tables;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.config.rev131024.tables.Table;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.SalTableService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.UpdateTableInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.table.update.UpdatedTableBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeatures;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TableFeaturesConsumerImpl {
    protected static final Logger logger = LoggerFactory.getLogger(TableFeaturesConsumerImpl.class);
    private SalTableService tableService;
    private TableDataCommitHandler commitHandler;
    private final IClusterContainerServices clusterContainerService = null;
    private IContainer container;
    private static final String NAMEREGEX = "^[a-zA-Z0-9]+$";
    private boolean inContainerMode; // being used by global instance only

    public TableFeaturesConsumerImpl() {
        InstanceIdentifier<? extends DataObject> path = InstanceIdentifier.builder(Tables.class).child(Table.class)
                .toInstance();
        tableService = FRMConsumerImpl.getProviderSession().getRpcService(SalTableService.class);

        if (null == tableService) {
            logger.error("Consumer SAL Service is down or NULL. FRM may not function as intended");
            System.out.println("Consumer SAL Service is down or NULL.");
            return;
        }

        System.out.println("-------------------------------------------------------------------");
        commitHandler = new TableDataCommitHandler();
        FRMConsumerImpl.getDataProviderService().registerCommitHandler(path, commitHandler);
        container = (IContainer) ServiceHelper.getGlobalInstance(IContainer.class, this);
    }

    /**
     * Updates TableFeatures to the southbound plugin and our internal database
     *
     * @param path
     * @param dataObject
     */
    private void updateTableFeatures(InstanceIdentifier<?> path, TableFeatures dataObject) {

        UpdateTableInputBuilder input = new UpdateTableInputBuilder();
        UpdatedTableBuilder updatedtablebuilder = new UpdatedTableBuilder();
        updatedtablebuilder.fieldsFrom(dataObject);
        List<TableFeatures> features = updatedtablebuilder.build().getTableFeatures();
        for (TableFeatures feature : features) {
            if (feature != null && feature.getMaxEntries() != null) {
                logger.error("Max Entries field is read-only, cannot be changed");
                return;
            }
        }
        input.setUpdatedTable(updatedtablebuilder.build());

        // We send table feature update request to the sounthbound plugin
        tableService.updateTable(input.build());
    }

    @SuppressWarnings("unchecked")
    private void commitToPlugin(internalTransaction transaction) {

        for (@SuppressWarnings("unused")
        Entry<InstanceIdentifier<?>, TableFeatures> entry : transaction.updates.entrySet()) {
            System.out.println("Coming update cc in TableDatacommitHandler");
            updateTableFeatures(entry.getKey(), entry.getValue());
        }

    }

    private final class TableDataCommitHandler implements DataCommitHandler<InstanceIdentifier<?>, DataObject> {

        @SuppressWarnings("unchecked")
        @Override
        public DataCommitTransaction requestCommit(DataModification<InstanceIdentifier<?>, DataObject> modification) {
            // We should verify transaction
            System.out.println("Coming in TableFeaturesDatacommitHandler");
            internalTransaction transaction = new internalTransaction(modification);
            transaction.prepareUpdate();
            return transaction;
        }
    }

    private final class internalTransaction implements DataCommitTransaction<InstanceIdentifier<?>, DataObject> {

        private final DataModification<InstanceIdentifier<?>, DataObject> modification;

        @Override
        public DataModification<InstanceIdentifier<?>, DataObject> getModification() {
            return modification;
        }

        public internalTransaction(DataModification<InstanceIdentifier<?>, DataObject> modification) {
            this.modification = modification;
        }

        Map<InstanceIdentifier<?>, TableFeatures> updates = new HashMap<>();

        /**
         * We create a plan which table features will be updated.
         *
         */
        void prepareUpdate() {

            Set<Entry<InstanceIdentifier<?>, DataObject>> puts = modification.getUpdatedConfigurationData().entrySet();
            for (Entry<InstanceIdentifier<?>, DataObject> entry : puts) {

                // validating the DataObject

                Status status = validate(container, (TableFeatures) entry);
                if (!status.isSuccess()) {
                    logger.warn("Invalid Configuration for table features The failure is {}", entry,
                            status.getDescription());
                    String error = "Invalid Configuration (" + status.getDescription() + ")";
                    logger.error(error);
                    return;
                }
                if (entry.getValue() instanceof TableFeatures) {
                    TableFeatures tablefeatures = (TableFeatures) entry.getValue();
                    preparePutEntry(entry.getKey(), tablefeatures);
                }

            }
        }

        private void preparePutEntry(InstanceIdentifier<?> key, TableFeatures tablefeatures) {
            if (tablefeatures != null) {
                // Updating the Map
                System.out.println("Coming update  in TableFeaturesDatacommitHandler");
                updates.put(key, tablefeatures);
            }
        }

        /**
         * We are OK to go with execution of plan
         *
         */
        @Override
        public RpcResult<Void> finish() throws IllegalStateException {

            commitToPlugin(this);
            // We return true if internal transaction is successful.
            // return Rpcs.getRpcResult(true, null, Collections.emptySet());
            return Rpcs.getRpcResult(true, null, null);
        }

        /**
         *
         * We should rollback our preparation
         *
         */
        @Override
        public RpcResult<Void> rollback() throws IllegalStateException {
            // NOOP - we did not modified any internal state during
            // requestCommit phase
            // return Rpcs.getRpcResult(true, null, Collections.emptySet());
            return Rpcs.getRpcResult(true, null, null);

        }

        public Status validate(IContainer container, TableFeatures dataObject) {

            String tablename = dataObject.getName();
            if (tablename == null || tablename.trim().isEmpty() || !tablename.matches(NAMEREGEX)
                    || tablename.length() != 32) {
                return new Status(StatusCode.BADREQUEST, "Invalid table name");
            }

            return new Status(StatusCode.SUCCESS);
        }
    }
}