package com.nttdata.calender.api;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Service;

import com.bmc.arsys.api.ARException;
import com.bmc.arsys.api.ARServerUser;
import com.bmc.arsys.api.Constants;
import com.bmc.arsys.api.Entry;
import com.bmc.arsys.api.Field;
import com.bmc.arsys.api.OutputInteger;
import com.bmc.arsys.api.QualifierInfo;
import com.bmc.arsys.api.SortInfo;
import com.bmc.arsys.api.Timestamp;
import com.bmc.arsys.api.Value;
import com.nttdata.calender.changes.Change;
import com.nttdata.calender.contracts.Contract;
import com.nttdata.calender.errorhandling.ErrorTypes.NotFoundError;
import com.nttdata.calender.states.State;
import com.nttdata.calender.supportgroup.SupportGroup;

import org.springframework.beans.factory.annotation.Autowired;
import com.nttdata.calender.ApplicationConfig;

/**
 * Java API for Remedy
 */
@Service
public class RemedyJavaAPI {

	private ARServerUser server;
	private String formName = "ASF:WI_TAS_Paket";
	private static Logger applicationLogger = LogManager.getLogger("application");
	// TODO: work with form CTM:Support Group
	private static final String QUALSTR = "\'Request ID\' != \"\"";
	private ApplicationConfig appConfig;

	// @org.springframework.beans.factory.annotation.Value("${greeting.message}")
	// private String greetingMessage;

	/**
	 * Sets up the Remedy API with the server and admin user/password.
	 */
    
	public RemedyJavaAPI(ApplicationConfig appConfig) throws ARException, NotFoundError {
		this.appConfig=appConfig;
		System.out.println(appConfig.getRssoActive());
		server = new ARServerUser();
		// server.setServer("itsm-app-dev.asfinag.at");
		server.setServer(this.appConfig.getArserver());
		server.setUser(this.appConfig.getAruser());
		server.setPassword(this.appConfig.getArpassword());
		server.setPort(this.appConfig.getArport());
		// server.setPort(50000);
		this.connect();

		// TODO: move to APIApplication.java or State.java - see where it fits
		State.getInstance().queryState(this);
		SupportGroup.getInstance().querySupportGroups(this);
	}

	public ARServerUser getServer() {
		return this.server;
	}

	/**
	 * Connects the current user to the server.
	 */
	void connect() throws ARException {
		applicationLogger.info("Connecting to AR Server");
		server.verifyUser();
		applicationLogger.info("Connected to AR Server " +
				server.getServer());
	}

	/**
	 * Calls to impersonate a user with the provided username.
	 * 
	 * @param userName the username
	 * @throws ARException when the user is unknown
	 */
	public void impersonateUser(String userName) throws ARException {

		if(!this.appConfig.getRssoActive())
			server.impersonateUser("WuiQualityKV");

		server.impersonateUser(userName);
	}

	/**
	 * Frees up the impersonated user and sets it to null.
	 */
	public void freeImpersonatedUser() {
		server.setImpersonatedUser(null);
	}

	/**
	 * Returns the currently impersonated user.
	 * 
	 * @return the impersonated user
	 */
	public String getUser() {
		return server.getImpersonatedUser();
	}

	/**
	 * Retrieves the name of the field in the database for the provided field ID and
	 * form name.
	 * This is necessary for the filters used in the `get` method of {@link Change}.
	 * 
	 * @param formName the form name
	 * @param fieldId  the field ID
	 * @return the database name
	 * @throws ARException when an ARException occurs
	 */
	public String getFieldDatabaseName(String formName, int fieldId) throws ARException {
		return server.getField(formName, fieldId).getName();
	}

	/**
	 * Creates an entry in a form using the given field values.
	 * 
	 * @param query the query
	 * @return the message indicating the entry has been created
	 * @throws ARException when an ARException occurs
	 */
	public String createEntry(Query query) throws ARException {
		var formName = query.getFormName();
		var values = query.getFieldValues();
		var entry = new Entry();

		values.forEach(value -> {
			entry.put(value.getFieldId(), value.getValue());
		});

		var entryIdOut = server.createEntry(formName, entry);
		applicationLogger.info("Entry created. The id # is " +
				entryIdOut);

		var lastStatus = server.getLastStatus();
		if (!server.getLastStatus().isEmpty()) {
			applicationLogger.info("Warning: " + lastStatus);
			return lastStatus.toString();
		}

		// return "Entry created successfully. ID: " + entryIdOut;
		return entryIdOut;
	}

	public String deleteEntry(String formName, String entryId) throws ARException {
		// Specify 0 for the deleteOption as mentioned in the documentation
		int deleteOption = 0;

		// Attempt to delete the entry
		server.deleteEntry(formName, entryId, deleteOption);

		// Check for any status or warnings after the deletion
		var lastStatus = server.getLastStatus();
		if (!lastStatus.isEmpty()) {
			applicationLogger.warn("Warning after deleting entry: " + lastStatus);
			return "Warning: " + lastStatus.toString();
		}

		applicationLogger.info("Entry with ID " + entryId + " deleted successfully from form " + formName);
		return "Entry deleted successfully. ID: " + entryId;
	}

	/**
	 * Takes an entry ID and a {@link Query} object with values and updates the
	 * selected entry with the values provided in the query.
	 * 
	 * @param entryId the entry ID
	 * @param updates the updates
	 * @throws ARException when an ARException occurs
	 */
	public String modifyEntry(String entryId, Query updates) throws ARException {
		var values = updates.getFieldValues();
		var entry = server.getEntry(updates.getFormName(), entryId, updates.getFieldIds());

		values.forEach(value -> {
			entry.put(value.getFieldId(), value.getValue());
		});
		server.setEntry(updates.getFormName(), entryId, entry, null, 0);
		return entryId;
	}

	/**
	 * Returns an entry given an entry ID with the fields specified in the
	 * {@link Query} object.
	 * 
	 * @param entryId the entry ID
	 * @param query   the query
	 * @return the entry
	 * @throws ARException when an ARException occurs
	 */
	public Entry getEntry(String entryId, Query query) throws ARException {
		return server.getEntry(query.getFormName(), entryId, query.getFieldIds());
	}

	/**
	 * Retrieves a list of {@link Entry} objects that match the specified qualifier,
	 * field IDs, and form name.
	 * 
	 * @param qualStr  the qualifier passed as a string
	 * @param fieldIds an array of integers representing the field IDs
	 * @param formName the name of the form to query from
	 * @param sorting  the sort info
	 * @return list of {@link Entry} objects that match the criteria
	 * @throws ARException when an ARException occurs
	 */
	public List<Entry> queryFieldsById(String qualStr, int[] fieldIds, String formName, SortInfo sorting,
			int sliceStart, int sliceEnd)
			throws ARException {
		if (qualStr.isEmpty())
			qualStr = QUALSTR;

		applicationLogger.info("Retrieving entries from Form :" + formName + "  with qualification " +
				qualStr);
		// Retrieve the detail info of all fields from the form.
		List<Field> fields = server.getListFieldObjects(formName);
		// Create the search qualifier.
		QualifierInfo qual = server.parseQualification(qualStr,
				fields, null, Constants.AR_QUALCONTEXT_DEFAULT);
		OutputInteger nMatches = new OutputInteger();
		List<SortInfo> sortOrder = new ArrayList<SortInfo>();
		if (sorting == null) {
			sortOrder.add(new SortInfo(2,
					Constants.AR_SORT_DESCENDING));
		} else {
			sortOrder.add(sorting);
		}

		// Retrieve entries from the form using the given
		// qualification.
		var settingMaxEntries = new int[] { Constants.AR_SERVER_INFO_MAX_ENTRIES };
		var serverSettings = server.getServerInfo(settingMaxEntries);
		var maxEntriesNumber = serverSettings.get(Constants.AR_SERVER_INFO_MAX_ENTRIES).getIntValue();

		if (sliceEnd == 0) {
			return getAllListEntryObjects(qual, formName, sortOrder, fieldIds, nMatches,
					maxEntriesNumber);
		}
		return getSomeListEntryObjects(sliceStart, sliceEnd, qual, formName, sortOrder, fieldIds, nMatches,
				maxEntriesNumber);
	}

	/**
	 * Retrieves all list entry objects based on the provided qualifier, form name,
	 * sort order, field IDs, maximum number of entries, and number of matches.
	 * Returns a list of all the retrieved list entry objects.
	 *
	 * @param qual             the qualifier info for filtering the list entry
	 *                         objects
	 * @param formName         the name of the form
	 * @param sortOrder        the list of sort information for ordering the list
	 *                         entry objects
	 * @param fieldIds         the array of field IDs to include in the list entry
	 *                         objects
	 * @param nMatches         the output integer to store the number of matches
	 * @param maxEntriesNumber the maximum number of entries to retrieve in each
	 *                         iteration
	 * @return a list of all the retrieved list entry objects
	 * @throws ARException if an AR exception occurs
	 */
	private List<Entry> getAllListEntryObjects(QualifierInfo qual, String formName,
			List<SortInfo> sortOrder, int[] fieldIds, OutputInteger nMatches, int maxEntriesNumber) throws ARException {
		List<Entry> entries = new ArrayList<Entry>();
		List<Entry> fetched = new ArrayList<Entry>();
		var sliceStart = 0;
		do {
			fetched = server.getListEntryObjects(
					formName, qual, sliceStart, 0,
					sortOrder, fieldIds, true, nMatches);
			sliceStart += fetched.size();
			entries.addAll(fetched);

		} while (fetched.size() == maxEntriesNumber);

		return entries;
	}

	/**
	 * Retrieves a slice of list entry objects based on the provided slice start and
	 * end indices,
	 * qualifier, form name, sort order, field IDs, maximum number of entries, and
	 * number of matches.
	 * Returns a list of the retrieved list entry objects within the specified
	 * slice.
	 *
	 * @param sliceStart       the start index of the slice
	 * @param sliceEnd         the end index of the slice
	 * @param qual             the qualifier info for filtering the list entry
	 *                         objects
	 * @param formName         the name of the form
	 * @param sortOrder        the list of sort information for ordering the list
	 *                         entry objects
	 * @param fieldIds         the array of field IDs to include in the list entry
	 *                         objects
	 * @param nMatches         the output integer to store the number of matches
	 * @param maxEntriesNumber the maximum number of entries to retrieve in each
	 *                         iteration
	 * @return a list of the retrieved list entry objects within the specified slice
	 * @throws ARException if an AR exception occurs
	 */
	private List<Entry> getSomeListEntryObjects(int sliceStart, int sliceEnd, QualifierInfo qual, String formName,
			List<SortInfo> sortOrder, int[] fieldIds, OutputInteger nMatches, int maxEntriesNumber) throws ARException {
		List<Entry> entries = new ArrayList<Entry>();
		List<Entry> fetched = new ArrayList<Entry>();
		var total = sliceEnd - sliceStart;
		var remainder = total % maxEntriesNumber;
		var loop = total / maxEntriesNumber;

		for (int i = 0; i < loop; i++) {
			fetched = server.getListEntryObjects(
					formName, qual, sliceStart, 0,
					sortOrder, fieldIds, true, nMatches);
			entries.addAll(fetched);
			sliceStart += fetched.size();
		}
		entries.addAll(server.getListEntryObjects(
				formName, qual, sliceStart, remainder,
				sortOrder, fieldIds, true, nMatches));

		return entries;
	}

	/**
	 * Retrieves the size of a form based on the provided qualification string and
	 * form name.
	 * Returns the size of the form.
	 *
	 * @param qualStr  the qualification string for filtering the form
	 * @param formName the name of the form
	 * @return the size of the form
	 * @throws ARException if an AR exception occurs
	 */
	public int getFormSize(String qualStr, String formName) throws ARException {
		List<Field> fields = server.getListFieldObjects(formName);
		QualifierInfo qual = server.parseQualification(qualStr,
				fields, null, Constants.AR_QUALCONTEXT_DEFAULT);
		var statistics = server.getEntryStatistics(server.getForm(formName).getKey(), qual, null,
				Constants.AR_STAT_OP_COUNT, null);
		return statistics.get(0).getResult().getIntValue();
	}

	/**
	 * Modifies entries by entry ID and field ID with a new date.
	 * 
	 * @param entryId the ID of the entry
	 * @param date    the new date to be modified
	 * @param fieldId the ID of the field
	 */
	void modifyEntryForReset(String entryId, Date date, int fieldId) throws ARException {
		Timestamp ts = new Timestamp(date);

		Entry entry = server.getEntry(formName, entryId, null);
		entry.put(fieldId, new Value(ts));
		if (entry.get(fieldId) != null) {
			server.setEntry(formName, entryId, entry, null, 0);
			System.out.println("Entry #" + entryId + " modified successfully.");
		}

	}

	public boolean isAdministrator() throws ARException {
		return server.isAdministrator();
	}
}