package com.gpc.tams.sync.site;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;

import javax.annotation.PostConstruct;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthScope;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.util.CollectionUtils;

import com.gpc.tams.config.ServerConfiguration;
import com.gpc.tams.consumer.Consumer;
import com.gpc.tams.consumer.converter.json.ConsumedServiceMapper;
import com.gpc.tams.enums.GeneralEnum;
import com.gpc.tams.enums.RefSiteType;
import com.gpc.tams.model.common.Relationship;
import com.gpc.tams.model.common.relation.RelationshipType;
import com.gpc.tams.model.request.Request;
import com.gpc.tams.repository.common.DataProcessedRegister;
import com.gpc.tams.repository.communication.CommunicationAccessNumber;
import com.gpc.tams.repository.communication.CommunicationUrl;
import com.gpc.tams.repository.reference.RefQueueTable;
import com.gpc.tams.repository.rowmapper.CommunicationRecordsMapper;
import com.gpc.tams.sync.AbstractSynchronizer;
import com.gpc.tams.util.DateUtil;
/**
 * Class to control sending site feed to ESB.
 * This is run as part of a scheduler defined in taap-servlet.xml.
 */
public class SiteSynchronizer extends AbstractSynchronizer<Relationship> {
    private static final String ESB_SERVICES_URL = "ESB_SERVICES_URL";
    @Value("${SITE_RELATIONSHIP_QUEUE}")private String queue;
    @Value("${SITE_RELATIONSHIP_PORT}")private String siteRelationshipPort;
    @Value("${SITE_RELATIONSHIP_SERVICE}")private String siteRelationshipService;
    @Value("${SITE_RELATIONSHIP_USERNAME}")private String siteRelationshipUserName;
    @Value("${SITE_RELATIONSHIP_PASSWORD}")private String siteRelationshipPassword;
    @Value("${SITE_RELATIONSHIP_DELAY}")protected String delay;
    @Autowired
    private HttpClient siteRelationshipHttpClient;
    @Autowired
    private ServerConfiguration serverConfig;
    
    /**
     * Does all the preparatory work. 
     * 1. Load communication URL.
     * 2. Set the URL in parent class.
     * 
     * If anything goes wrong, we are not allowing server to start so that support get 
     * involved quickly and the problem can be corrected sooner rather than later. 
     */
    @PostConstruct
    public void init(){
        try{
            final CommunicationUrl esbServerURL = communicationURLDAO.find(serverConfig.getString(ESB_SERVICES_URL));
            setUrl(esbServerURL.getUrl(), Integer.parseInt(siteRelationshipPort), siteRelationshipService);
            siteRelationshipHttpClient.getParams().setAuthenticationPreemptive(true);
            siteRelationshipHttpClient.getState().setCredentials(AuthScope.ANY, 
                    new UsernamePasswordCredentials(siteRelationshipUserName, siteRelationshipPassword));
            final List<RefQueueTable> tables = referenceDAO.loadQueueTables();
            for(final RefQueueTable table : tables){
                if(queue.equals(table.getTableName())){
                    tableId = table.getId();
                    break;
                }
            }
        }catch(Exception exception){
            context.logError(exception, "");
        }
    }
    /* (non-Javadoc)
     * @see com.gpc.tams.sync.AbstractSynchronizer#getDelay()
     */
    @Override
    protected long getDelay() {
        return Long.valueOf(delay);
    }
    /* (non-Javadoc)
     * @see com.gpc.tams.sync.AbstractSynchronizer#getServiceKey()
     */
    @Override
    protected String getServiceKey() {
        return "feedSite";
    }
    /* (non-Javadoc)
     * @see com.gpc.tams.sync.AbstractSynchronizer#getRetry()
     */
    @Override
    public int getRetry() {
        /*
         * This service is going to run once in a day. So try for 10 times and log reason for failing if it continues.
         */
        return 10;
    }
    
    /*
     * (non-Javadoc)
     * @see com.gpc.tams.sync.AbstractSynchronizer#checkForUpdates(com.gpc.tams.repository.common.DataProcessedRegister)
     */
    @Override
    protected RecordSynchronizationData checkForUpdates(DataProcessedRegister processedRegister) {
        /*
         * Check if store is allowed to send feed. If not, just return back by printing a debug statement.
         */
        if(!storeProfileDAO.find().isUseSiteRelationshipFeed()){
            context.logDebug("USE_SITE_RELATIONSHIP_FEED switch is off. Not sending feed.");
            return null;
        }
        final int location = storeProfileDAO.find().getLocation();
        final int maxIdFromQueue = communicationDirectoryChangeQueueDAO.findMaximumChangeQueueId(location);
        final int minIdFromQueue = communicationDirectoryChangeQueueDAO.findMinimumChangeQueueId(location);
        /*
         * Check if there are any changes from the previous batch sent. if there are no changes no need to go further.
         */
        if(processedRegister != null && processedRegister.getLastPointerProcessed() == maxIdFromQueue) {
            context.logDebug("No chnages from the last batch sent. Not sending feed.");
            return null;
        }
        
        final int minQueueId = (processedRegister == null || processedRegister
                .getLastPointerProcessed() == 0) ? minIdFromQueue : (processedRegister
                .getLastPointerProcessed() + 1);
        final int maxQueueId = maxIdFromQueue;
        
        final List<CommunicationAccessNumber>records = databaseOperationsService.getCommunicationRecords(2, 
                storeProfileDAO.find().getLocation(), CommunicationRecordsMapper.INSTANCE);
        if(CollectionUtils.isEmpty(records)){
            context.logDebug("No communication directory records found.");
            return null;
        }
        final List<Relationship>relations = new ArrayList<Relationship>();
        for(final CommunicationAccessNumber record: records){
            final Relationship relatedSite = new Relationship();
            relatedSite.setName(GeneralEnum.NINE_DIGIT_STORE.toString());
            relatedSite.setValue(record.getCommunicationDirectory().getStoreNumber());
            context.logTrace("feedSite - StoreNumber= "+record.getCommunicationDirectory().getStoreNumber());
            relatedSite.setSourceType(RefSiteType.Store.toString());
            relatedSite.setModifiedDate(DateUtil.getEpoch(record.getCommunicationDirectory().getLastModifiedDate()));
            final RelationshipType relationshipType = new RelationshipType();
            relationshipType.setName(GeneralEnum.POS_INVENTORY_FRIEND.toString());
            relationshipType.setRanking(record.getCommunicationDirectory().getIsscSearchSequence());
            relatedSite.setRelationshipType(relationshipType);
            relations.add(relatedSite);
        }
        
        final RecordSynchronizationData recordSynchronizationData = new RecordSynchronizationData();
        recordSynchronizationData.setModifiedRecords(relations);
        recordSynchronizationData.setFirstPointer(minQueueId);
        recordSynchronizationData.setLastPointer(maxQueueId);
        return recordSynchronizationData;
    }
    
    /*
     * (non-Javadoc)
     * @see com.gpc.tams.sync.AbstractSynchronizer#sendDeletedRecords(java.util.List, java.sql.Timestamp)
     */
    @Override
    protected void sendDeletedRecords(List<Relationship> deletedData, Timestamp processedDate) {
    }
    
    /*
     * (non-Javadoc)
     * @see com.gpc.tams.sync.AbstractSynchronizer#sendModifiedRecords(java.util.List, java.sql.Timestamp)
     */
    @Override
    protected void sendModifiedRecords(List<Relationship> modifiedData, Timestamp processedDate) {
        final Relationship site = new Relationship();
        site.setRelations(modifiedData);
        final Request<Relationship> request = new Request<Relationship>();
        request.setHeader(populateHeader());
        request.setDetail(site);
        new Consumer(new ConsumedServiceMapper(getServiceKey(), validateAndMutateDelegator), 
               siteRelationshipHttpClient).post(getUrl(), request, Object.class);
    }
}