D-Net

package eu.dnetlib.data.collector.plugins.doiresolver;

import eu.dnetlib.data.collector.plugins.utils.JsonUtils;

import org.apache.commons.lang.StringUtils;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import java.io.IOException;

import java.nio.file.Files;

import java.nio.file.Paths;

import java.util.Iterator;

import java.util.concurrent.ArrayBlockingQueue;

public class DOIResolverIterator implements Iterator<String> {

    private static final Log log = LogFactory.getLog(DOIResolverIterator.class);

    private static final String STARTER = "FIRE";

    private static final String TERMINATOR = "ARNOLD";

    private static final String BAD_TERMINATOR = "BAD";

    private static final String UNRESOLVED = "UNRESOLVED";

    /** Path to the file that contains a list of DOIs, one per line. **/

    private String filePath;

    private ArrayBlockingQueue<String> queue;

    private CrossrefResolver crossrefResolver;

    public DOIResolverIterator(final String filePath, final CrossrefResolver crossrefResolver) {

        this.filePath = filePath;

        this.queue = new ArrayBlockingQueue<>(100);

        this.crossrefResolver = crossrefResolver;

        init();

    }

    private void init(){

        new Thread(() -> {

            // put first item in the queue

            if(queue.offer(STARTER)) {

                // read the file, ask the resolvers, put results in a shared queue

                //whatever exceptions, add terminator to the queue

                try{

                    Files.lines(Paths.get(filePath)).forEach(doi -> queue.offer(resolve(doi)));

                } catch (IOException e) {

                    log.error(e);

                    queue.offer(BAD_TERMINATOR);

                }

            }

            queue.offer(TERMINATOR);

        }

        ).start();

    }

    private String resolve(final String doi){

       log.debug("Resolving "+doi);

       log.debug("Crossref...");

       String record = crossrefResolver.resolve(cleanDOI(doi));

       if(StringUtils.isNotBlank(record)) return record;

       else {

           //try another resolver

       }

       return UNRESOLVED;

    }

    /**

     * Returns the identifier part of the DOI only.

     * @param doi

     * @return the DOI

     */

    protected String cleanDOI(final String doi){

       return doi.replace("http://dx.doi.org/", "").replace("https://dx.doi.org/", "");

    }

    @Override

    public boolean hasNext() {

        //If I get a null value, the queue is currently empty. so we wait for something

        if(queue.peek() == null){

            try {

                Thread.sleep(10);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            return hasNext();

        }

       if(queue.peek().equals(TERMINATOR) || queue.peek().equals(BAD_TERMINATOR)){

           return false;

       }

       if(queue.peek().equals(UNRESOLVED) || queue.peek().equals(STARTER)){

           queue.poll();

           return hasNext();

       }

        return true;

    }

    @Override

    public String next() {

        return queue.poll();

    }

    public String getFilePath() {

        return filePath;

    }

    public void setFilePath(String filePath) {

        this.filePath = filePath;

    }

    public CrossrefResolver getCrossrefResolver() {

        return crossrefResolver;

    }

    public void setCrossrefResolver(CrossrefResolver crossrefResolver) {

        this.crossrefResolver = crossrefResolver;

    }

}