import ch.lambdaj.function.convert.Converter;

import com.hp.hpl.jena.query.QuerySolution;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.sba_research.timbus.kb.FormatMigrationOption;

import org.sbaresearch.owl.AlternativesBuilder;

import org.semanticweb.owlapi.io.OWLXMLOntologyFormat;

import org.semanticweb.owlapi.io.StringDocumentTarget;

import uk.ac.manchester.cs.owl.owlapi.OWLOntologyImpl;

import static ch.lambdaj.Lambda.convert;

    public static final IRI IRI_OBJECT_CHARACTERISTICS_PROPERTY = IRI.create("http://multimedialab.elis.ugent.be/users/samcoppe/ontologies/Premis/premis.owl#objectCharacteristics");

    public static final IRI IRI_OBJECT_CHARACTERISTICS = IRI.create("http://www.loc.gov/premis/rdf/v1#ObjectCharacteristics");

    public static final IRI IRI_FORMAT_PROPERTY = IRI.create("http://id.loc.gov/ontologies/premis.rdf#Format");

    public static final IRI IRI_FORMAT_REGISTRY = IRI.create("http://id.loc.gov/ontologies/premis.rdf#FormatRegistry");

    public static final IRI IRI_FORMAT_REGISTRY_PROPERTY = IRI.create("http://id.loc.gov/ontologies/premis.rdf#FormatRegistry");

    public static final IRI IRI_FORMAT_REGISTRY_KEY_PROPERTY = IRI.create("http://www.loc.gov/premis/rdf/v1#hasFormatRegistryKey");

    public static final IRI IRI_FORMAT_REGISTRY_NAME_PROPERTY = IRI.create("http://www.loc.gov/premis/rdf/v1#hasFormatRegistryName");

    public static final String IRIPREFIX_CHANGES = "http://timbus.teco.edu/ontologies/preservationChanges/";

    public static final IRI IRI_PREMIS = IRI.create("http://multimedialab.elis.ugent.be/users/samcoppe/ontologies/Premis/premis.owl");

    public static final OWLClass PREMIS_EVENT_CLASS = OWLManager.getOWLDataFactory().getOWLClass(

            IRI.create(IRI_PREMIS.toString() + "#", "Event"));

    public static final OWLObjectProperty PREMIS_LINKING_SOURCE_OBJECTPROPERTY = OWLManager.getOWLDataFactory().getOWLObjectProperty(

            IRI.create(IRI_PREMIS.toString() + "#", "linkingSourceObject"));

    public static final OWLObjectProperty PREMIS_LINKING_OUTCOME_OBJECTPROPERTY = OWLManager.getOWLDataFactory().getOWLObjectProperty(

            IRI.create(IRI_PREMIS.toString() + "#", "linkingOutcomeObject"));

    public static final Set<OWLAnnotation> EMPTY_OWL_ANNOTATIONS = Collections.emptySet();

            String affectedResourceName = identifiedRisk.getAffectedResource();

            IRI individualAtRisk = findIndividual(originalModelFacade, affectedResourceName);

            if (individualAtRisk == null) continue; // ignore affected resources that could not be found

            // currently only look at system software

                addToolAlternatives(baseURL, identifier, alternatives, originalModelFacade, identifiedRisk, affectedResourceName, individualInOriginalModel);

                addFileAlternatives(baseURL, identifier, alternatives, originalModelFacade, identifiedRisk, individualAtRisk);

                continue;

    private void addFileAlternatives(String baseURL, String identifier, ArrayList<PreservationAlternative> alternatives, OwlApiFacade originalModelFacade, Risk identifiedRisk, IRI individualAtRisk) throws OWLOntologyCreationException, OWLOntologyStorageException, IOException, OwlElementNotFoundException {

        System.out.println("Searching for file alternatives...");

        List<FormatMigrationOption> alternativeFormats = getAlternativeFormats(originalModelFacade, individualAtRisk);

        AlternativesBuilder alternativesBuilder = new AlternativesBuilder(originalModelFacade);

        for (int i = 0; i < alternativeFormats.size(); ++i) {

            String formatName = alternativeFormats.get(i).getFormat();

            String toolName = alternativeFormats.get(i).getTool();

            System.out.println(String.format("Replacing %s with %s using %s.", individualAtRisk, formatName, toolName));

            String alternativeOntologyIri = createIriFragment(baseURL, identifier, identifiedRisk, i);

            OwlApiFacade modifiedModel = new OwlApiFacade(alternativesBuilder.copyOntology(IRI.create(alternativeOntologyIri, originalModelFacade.getOntology().getOntologyID().getOntologyIRI().getFragment())));

            OWLNamedIndividual individual = modifiedModel.addIndividual(formatName + "_file", IRI_FILE.toString());

            OWLNamedIndividual objectCharacteristics = modifiedModel.addIndividual(formatName + "Characteristics", IRI_OBJECT_CHARACTERISTICS.toString());

            modifiedModel.addObjectProperty(individual, IRI_OBJECT_CHARACTERISTICS_PROPERTY.toString(), objectCharacteristics);

            OWLNamedIndividual format = modifiedModel.addIndividual(formatName + "Format");

            modifiedModel.addObjectProperty(objectCharacteristics, IRI_FORMAT_PROPERTY.toString(), format);

            OWLNamedIndividual formatRegistry = modifiedModel.addIndividual(formatName + "FormatRegistry", IRI_FORMAT_REGISTRY.toString());

            modifiedModel.addObjectProperty(format, IRI_FORMAT_REGISTRY_PROPERTY.toString(), formatRegistry);

            modifiedModel.addDataProperty(formatRegistry, IRI_FORMAT_REGISTRY_NAME_PROPERTY.toString(), OWLManager.getOWLDataFactory().getOWLLiteral("http://www.nationalarchives.gov.uk/PRONOM/"));

            List<String> pronom_ids = knowledgeBase.getFormatIDs(formatName);

            for (String pronom_id: pronom_ids) {

                modifiedModel.addDataProperty(formatRegistry, IRI_FORMAT_REGISTRY_KEY_PROPERTY.toString(), OWLManager.getOWLDataFactory().getOWLLiteral(pronom_id));

            }

            if (pronom_ids.isEmpty()) {

                modifiedModel.addDataProperty(formatRegistry, IRI_FORMAT_REGISTRY_KEY_PROPERTY.toString(), OWLManager.getOWLDataFactory().getOWLLiteral("fmt/null"));

            }

            // TODO: copy relations

            // TODO: remove original individual

            // TODO: add converting tool to the changes ontology!

            IRI changesOntologyIri = IRI.create(IRIPREFIX_CHANGES + identifier + "/" + i);

            OWLOntology eventsOntology = createChangesOntology(

                    changesOntologyIri, originalModelFacade.getOntology(), originalModelFacade.getIndividual(individualAtRisk.toString()),

                    modifiedModel.getOntology(), individual, "FileReplacement");

            alternatives.add(new PreservationAlternative(

                    originalModelFacade.toOwlXml(), modifiedModel.toOwlXml(),

                    OwlApiFacade.toOwlXml(eventsOntology), identifiedRisk.getRiskIdentifier(), new ArrayList<String>()));

        }

        // TODO: avoid duplicate filecharacteristics and registries somehow

    }

    private void addToolAlternatives(String baseURL, String identifier, ArrayList<PreservationAlternative> alternatives, OwlApiFacade originalModelFacade, Risk identifiedRisk, String affectedResourceName, OWLNamedIndividual individualInOriginalModel) throws OWLOntologyStorageException, OWLOntologyCreationException, IOException, OwlElementNotFoundException {

        List<String> alternativeTools = getAlternativeTools(originalModelFacade, affectedResourceName);

        if (alternativeTools.size() < 1) {

            System.out.println("No alternatives found for risk: " + identifiedRisk.getRiskIdentifier());

            System.out.println("Using fake alternatives for test purposes...");

            for (int i = 0; i < 3; ++i) {

                System.out.println("Replacing identified software " + affectedResourceName);

                String replacingIndividual = affectedResourceName + "-replacement_" + i;

                String alternativeOntologyIri = createIriFragment(baseURL, identifier, identifiedRisk, i);//, originalModel.getOntologyID().getOntologyIRI());

                IRI changesOntologyIri = IRI.create(IRIPREFIX_CHANGES + identifier + "/" + i);

                alternatives.add(createAlternativeOntology(originalModelFacade.getOntology(), identifiedRisk,

                        individualInOriginalModel, replacingIndividual, alternativeOntologyIri, changesOntologyIri));

            }

        } else {

            for (int i = 0; i < alternativeTools.size(); ++i) {

                System.out.println("Replacing identified software " + affectedResourceName);

                String alternativeOntologyIri = createIriFragment(baseURL, identifier, identifiedRisk, i);//, originalModel.getOntologyID().getOntologyIRI());

                IRI changesOntologyIri = IRI.create(IRIPREFIX_CHANGES + identifier + "/" + i);

                alternatives.add(createAlternativeOntology(originalModelFacade.getOntology(), identifiedRisk,

                        individualInOriginalModel, alternativeTools.get(i), alternativeOntologyIri, changesOntologyIri));

            }

        }

    }

    private IRI findIndividual(OwlApiFacade originalModelFacade, String affectedResourceName) throws OwlElementNotFoundException {

        return originalModelFacade.findIndividualByFragmentAndLabel(affectedResourceName);

    }

    private List<String> getAlternativeTools(OwlApiFacade originalModelFacade, String affectedResourceName) throws OWLOntologyStorageException, OWLOntologyCreationException, IOException {

        // get alternatives based on the tool

        List<String> alternativeTools = knowledgeBase.getAlternativeTools(affectedResourceName);

        // get alternatives based on the formats

        JenaQueryFacade originalModelQueryFacade = new JenaQueryFacade(originalModelFacade.getJenaModel(false));

        List<Pair<String, String>> formatPairs = convertToIDs(originalModelQueryFacade.query(QueryHelper.getQueryFormatPairs(affectedResourceName)), originalModelQueryFacade);

        for (Pair<String, String> formatPair : formatPairs) {

            alternativeTools.addAll(JenaQueryFacade.removeNamespace(knowledgeBase.getSupportingTools(formatPair)));

        }

        return alternativeTools;

    }

    private List<FormatMigrationOption> getAlternativeFormats(OwlApiFacade originalModelFacade, IRI fileAtRisk) throws OWLOntologyStorageException, OWLOntologyCreationException, IOException {

        // get alternatives based on the tool

        JenaQueryFacade queryFacade = new JenaQueryFacade(originalModelFacade.getJenaModel(false));

        List<String> pronomIDs = JenaQueryFacade.extractColumn(queryFacade.query(QueryHelper.getQueryGetFormatID(fileAtRisk.toString())), "pronom_id");

        List<FormatMigrationOption> alternativeTools = knowledgeBase.getConvertToMigrationOptions(pronomIDs.get(0)); // TODO: also get ConvertFromMigrationOptions!

        System.out.println("Alternative options found: " + alternativeTools);

        return alternativeTools;

    }

    private PreservationAlternative createAlternativeOntology(OWLOntology originalModel,

                                                              Risk identifiedRisk, OWLNamedIndividual individualInOriginalModel,

                                                              String replacingIndividual, String alternativeOntologyIriPrefix, IRI changesOntologyIri) throws OWLOntologyCreationException, OwlElementNotFoundException, OWLOntologyStorageException {

        AlternativesBuilder alternativesBuilder = new AlternativesBuilder(new OwlApiFacade(originalModel));

        OWLOntology modifiedModel = alternativesBuilder.copyOntology(IRI.create(alternativeOntologyIriPrefix, originalModel.getOntologyID().getOntologyIRI().getFragment()));

        OWLOntologyManager modifiedModelOntologyManager = modifiedModel.getOWLOntologyManager();

        IRI individualInModifiedModelModifiedIRI = null;

        if (originalModel.containsIndividualInSignature(individualInOriginalModel.getIRI())) {

            individualInModifiedModelModifiedIRI = renameIndividual(individualInOriginalModel, replacingIndividual, modifiedModel);

        }

        List<String> changedOntologies = new ArrayList<String>();

        for (OWLOntology ontology : originalModel.getDirectImports()) {

            if (!ontology.containsIndividualInSignature(individualInOriginalModel.getIRI())) continue;

            AlternativesBuilder alternativesBuilderImportedOntology = new AlternativesBuilder(new OwlApiFacade(ontology));

            OWLOntology modifiedOntology = alternativesBuilderImportedOntology.copyOntology(

                    IRI.create(alternativeOntologyIriPrefix, ontology.getOntologyID().getOntologyIRI().getFragment()),

                    modifiedModel.getOWLOntologyManager()

            );

            individualInModifiedModelModifiedIRI = renameIndividual(individualInOriginalModel, replacingIndividual, modifiedOntology);

            modifiedModelOntologyManager.applyChange(new RemoveImport(modifiedModel,

                    modifiedModelOntologyManager.getOWLDataFactory().getOWLImportsDeclaration(ontology.getOntologyID().getOntologyIRI())));

            modifiedModelOntologyManager.applyChange(new AddImport(modifiedModel,

                    modifiedModelOntologyManager.getOWLDataFactory().getOWLImportsDeclaration(modifiedOntology.getOntologyID().getOntologyIRI())));

            changedOntologies.add(ontologyToXMLString(modifiedOntology));

        }

        OWLNamedIndividual modifiedIndividual = modifiedModelOntologyManager.getOWLDataFactory().getOWLNamedIndividual(individualInModifiedModelModifiedIRI);

        OWLOntology eventsOntology = createChangesOntology(changesOntologyIri, originalModel, individualInOriginalModel, modifiedModel, modifiedIndividual, "SoftwareReplacement");

        return new PreservationAlternative(

                ontologyToXMLString(originalModel), ontologyToXMLString(modifiedModel),

                ontologyToXMLString(eventsOntology), identifiedRisk.getRiskIdentifier(), changedOntologies);

    }

    private String createIriFragment(String baseURL, String identifier, Risk identifiedRisk, int count) {

        return baseURL + "/" + identifier + "/" + identifiedRisk.getRiskIdentifier()

                + "/" + count + "/";

    }

    private OWLOntology createChangesOntology(IRI iri, OWLOntology originalModel, OWLNamedIndividual individualInOriginalModel, OWLOntology modifiedModel, OWLNamedIndividual individualInModifiedModel, String replacementName) {

        // Finally, create the ontology that contains the PREMIS events

        OWLOntology eventsOntology = new OWLOntologyImpl(modifiedModel.getOWLOntologyManager(),

                new OWLOntologyID(iri));

        OWLOntologyManager eventsOntologyManager = eventsOntology.getOWLOntologyManager();

        OWLDataFactory eventsDataFactory = eventsOntologyManager.getOWLDataFactory();

        // import PREMIS OWL

        eventsOntologyManager.applyChange(new AddImport(eventsOntology,

                eventsDataFactory.getOWLImportsDeclaration(IRI_PREMIS)));

        eventsOntologyManager.applyChange(new AddImport(

                eventsOntology,

                eventsDataFactory.getOWLImportsDeclaration(originalModel.getOntologyID().getOntologyIRI())));

        eventsOntologyManager.applyChange(new AddImport(

                eventsOntology,

                eventsDataFactory.getOWLImportsDeclaration(modifiedModel.getOntologyID().getOntologyIRI())));

        // Make a new event individual

        OWLNamedIndividual eventIndividual = eventsDataFactory.getOWLNamedIndividual(IRI.create(

                iri.getNamespace(), replacementName));

        OWLClassAssertionAxiom eventClassAxiom = eventsDataFactory.getOWLClassAssertionAxiom(

                PREMIS_EVENT_CLASS, eventIndividual);

        eventsOntologyManager.applyChange(new AddAxiom(eventsOntology, eventClassAxiom));

        // Link the event individual to the entities

        OWLObjectPropertyAssertionAxiom linkingSourceObjectPropertyAxiom = eventsDataFactory.getOWLObjectPropertyAssertionAxiom(

                PREMIS_LINKING_SOURCE_OBJECTPROPERTY, eventIndividual, individualInOriginalModel,

                EMPTY_OWL_ANNOTATIONS);

        eventsOntologyManager.applyChange(new AddAxiom(eventsOntology, linkingSourceObjectPropertyAxiom));

        OWLObjectPropertyAssertionAxiom linkingOutcomeObjectPropertyAxiom = eventsDataFactory.getOWLObjectPropertyAssertionAxiom(

                PREMIS_LINKING_OUTCOME_OBJECTPROPERTY, eventIndividual, individualInModifiedModel,

                EMPTY_OWL_ANNOTATIONS);

        eventsOntologyManager.applyChange(new AddAxiom(eventsOntology,

                linkingOutcomeObjectPropertyAxiom));

        return eventsOntology;

    }

    private IRI renameIndividual(OWLNamedIndividual individualInOriginalModel, String replacingIndividual, OWLOntology modifiedModel) throws OwlElementNotFoundException {

        OwlApiFacade model = new OwlApiFacade(modifiedModel);

        IRI sourceIRI = model.createIri(OwlApiFacade.getFragment(individualInOriginalModel.getIRI()));

        if (!model.containsIndividual(sourceIRI.toString())) {

            throw new PreservationIdentifierException("Original individual not found in modified model: " + sourceIRI);

        }

        AlternativesBuilder alternativesBuilder = new AlternativesBuilder(model);

        alternativesBuilder.renameIndividualByIRI(model.createIri(OwlApiFacade.getFragment(individualInOriginalModel.getIRI())), replacingIndividual); // TODO: not sure why fragment only does not work... bug!

        IRI targetIRI = model.createIri(replacingIndividual);

        if (!model.containsIndividual(targetIRI.toString())) {

            throw new PreservationIdentifierException("Modified individual not found in modified model: " + targetIRI);

        }

        System.out.println("\tReplaced " + sourceIRI + " with " + targetIRI);

        return targetIRI;

    }

    public static String ontologyToXMLString(OWLOntology ontology) {

        StringDocumentTarget stringDocumentTarget = new StringDocumentTarget();

        try {

            OWLManager.createOWLOntologyManager().saveOntology(ontology, new OWLXMLOntologyFormat(),

                    stringDocumentTarget);

        } catch (OWLOntologyStorageException e) {

            e.printStackTrace();

        }

        return stringDocumentTarget.toString();

    }

    private List<Pair<String, String>> convertToIDs(List<QuerySolution> query, final JenaQueryFacade queryFacade) {

        return convert(query, new Converter<QuerySolution, Pair<String, String>>() {

            public Pair<String, String> convert(QuerySolution solution) {

                return new ImmutablePair<String, String>(getID(solution, "readFormat", queryFacade), getID(solution, "writeFormat", queryFacade));

            }

        });

    }

    private String getID(QuerySolution solution, String formatIndex, JenaQueryFacade queryFacade) {

        String format = solution.contains(formatIndex) ? solution.get(formatIndex).toString() : null;

        if (format == null) return null;

        List<String> pronomIDs = JenaQueryFacade.extractColumn(queryFacade.query(QueryHelper.getQueryGetFormatID(format)), "pronom_id");

        return (pronomIDs.size() > 0 ? pronomIDs.get(0) : format);

    }