package ca.uhn.hl7v2.util;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileFilter;
import java.io.FileReader;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import ca.uhn.hl7v2.ErrorCode;
import ca.uhn.hl7v2.HL7Exception;

/**
 * <p>Implements CodeMapper using files to store code values.  Files are arranged
 * in the following directory structure.  The base directory is called "codemap".
 * This should be created under the hapi.home directory (see Home class; defaults to .).
 * Under the base directory, there should be one directory for each interface, and
 * each of these directories should be named after the interface.  For example if you
 * had interfaces to pharmacy and lab systems you might have the following directories:</p>
 * <p> <hapi.home>/codemap/pharmacy<br>
 * <hapi.home>/codemap/lab</p>
 * <p>Each directory should contain two files per HL7 table, named after the table numbers as
 * follows: "hl7nnnn.li" and "hl7nnnn.il", where nnnn is the 4 digit table number.  The .il
 * file contains maps from interface codes to local codes, and the .li file contains maps from
 * local codes to interface codes (these unfortunately may not be symmetrical).</p>
 * <p>Each line of a file contains a single code map, with the "from" value and the "to" value
 * separated by a tab.  For example, the file <hapi.home>/lab/HL70001.li (to map local codes to interface
 * codes for the HL7 admnistrative sex table in your lab system interface) might contain the
 * following line: </p>
 * <p>male&tab;M</p>
 * <p>This means that the local code "male" maps to the interface code "M".</p>
 * <p>Lines that start with "//" are treated as comments.</p>
 * @author Bryan Tripp
 */
public class FileCodeMapper extends CodeMapper {

    private static final Logger log = LoggerFactory.getLogger(FileCodeMapper.class);

    private boolean throwIfNoMatch = false;
    final File baseDir;
    private Map<String, Map<String, Map<String, String>>> interfaceToLocal;
    private Map<String, Map<String, Map<String, String>>> localToInterface;

    /**
     * Creates a new instance of FileCodeMapper.  You should probably not
     * construct a FileCodeMapper directly.  Use CodeMapper.getInstance()
     * instead ... this will ensure that only a single instance is created,
     * which is important for performance because code maps are loaded from
     * disk every time this constructor is called.
     */
    public FileCodeMapper() throws HL7Exception {
        baseDir = new File(Home.getHomeDirectory().getAbsolutePath() + "/codemap");
        refreshCache();
    }

    /**
     * If values are cached in such a way that they are not guaranteed to be current, a call
     * to this method refreshes the values.
     */
    public void refreshCache() throws HL7Exception {
        localToInterface = new HashMap<>(10);
        interfaceToLocal = new HashMap<>(10);

        log.info("Refreshing cache");

        try {
            //get list of child directories
            File[] interfaceDirs = this.baseDir.listFiles(pathname -> {
                boolean acc = false;
                if (pathname.isDirectory())
                    acc = true;
                return acc;
            });

            //loop through directories and set up maps
            for (File interfaceDir : interfaceDirs) {

                log.info(
                        "Checking directory {} for interface code maps.", interfaceDir.getName());

                //get list of .li (local -> interface) and .il (interface -> local) files
                File[] mapFiles = interfaceDir.listFiles((dir, name) -> {
                    boolean acc = false;
                    if (name.toUpperCase().startsWith("HL7")) {
                        if (name.substring(name.lastIndexOf('.')).equals(".li")
                                || name.substring(name.lastIndexOf('.')).equals(".il"))
                            acc = true;
                    }
                    return acc;
                });

                //read map entries from each file and add to hash maps for li and il codes
                HashMap<String, Map<String, String>> li = new HashMap<>(50);
                HashMap<String, Map<String, String>> il = new HashMap<>(50);
                for (File mapFile : mapFiles) {
                    log.info("Reading map entries from file {}", mapFile);

                    String fName = mapFile.getName();
                    String tableName = fName.substring(0, fName.lastIndexOf('.'));
                    String mapDirection = fName.substring(fName.lastIndexOf('.') + 1);

                    //read values and store in HashMap
                    Map<String, String> codeMap = new HashMap<>(25);
                    try (BufferedReader in = new BufferedReader(new FileReader(mapFile))) {
                        while (in.ready()) {
                            String line = in.readLine();
                            if (!line.startsWith("//")) {
                                StringTokenizer tok = new StringTokenizer(line, "\t", false);
                                String from = null;
                                String to = null;
                                if (tok.hasMoreTokens())
                                    from = tok.nextToken();
                                if (tok.hasMoreTokens())
                                    to = tok.nextToken();
                                if (from != null && to != null)
                                    codeMap.put(from, to);
                            }
                        }
                    }

                    //add to appropriate map for this interface
                    if (mapDirection.equals("il")) {
                        il.put(tableName.toUpperCase(), codeMap);
                        log.debug("Adding {} codes to interface -> local map for {} in {} interface",
                                codeMap.size(), tableName, interfaceDir.getName());
                    } else {
                        li.put(tableName.toUpperCase(), codeMap);
                        log.debug("Adding {} codes to local -> interface map for {} in {} interface",
                                codeMap.size(), tableName, interfaceDir.getName());
                    }
                }

                //add maps for this interface (this directory) to global list
                interfaceToLocal.put(interfaceDir.getName(), il);
                localToInterface.put(interfaceDir.getName(), li);
            }

        }
        catch (IOException e) {
            throw new HL7Exception(
                "Can't read interface code maps from disk", e);
        }
    }

    /**
     * Returns the local code for the given interface code as it appears in
     * the given interface.
     */
    public String getLocalCode(String interfaceName, int hl7Table, String interfaceCode) throws HL7Exception {
        String localCode = null;
        try {
            Map<String, Map<String, String>> interfaceMap = interfaceToLocal.get(interfaceName);
            localCode = getCode(interfaceMap, hl7Table, interfaceCode);
        }
        catch (NullPointerException npe) {
            if (this.throwIfNoMatch)
                throw new HL7Exception(
                    "No local mapping for the interface code "
                        + interfaceCode
                        + " for HL7 table "
                        + hl7Table
                        + " for the interface '"
                        + interfaceName
                        + "'",
                    ErrorCode.TABLE_VALUE_NOT_FOUND);
        }
        return localCode;
    }

    /**
     * Common code for getLocalcode and getInterfaceCode
     */
    private String getCode(Map<String, Map<String, String>> interfaceMap, int hl7Table, String code) {
        String ret;

        //get map for the given table
        StringBuilder tableName = new StringBuilder();
        tableName.append("HL7");
        if (hl7Table < 1000)
            tableName.append("0");
        if (hl7Table < 100)
            tableName.append("0");
        if (hl7Table < 10)
            tableName.append("0");
        tableName.append(hl7Table);
        Map<String, String> tableMap = interfaceMap.get(tableName.toString());

        //get code
        ret = tableMap.get(code);
        return ret;
    }

    /**
     * Returns the interface code for the given local code, for use in the context
     * of the given interface.
     */
    public String getInterfaceCode(String interfaceName, int hl7Table, String localCode) throws HL7Exception {
        String interfaceCode = null;
        try {
            Map<String, Map<String, String>> interfaceMap = localToInterface.get(interfaceName);
            interfaceCode = getCode(interfaceMap, hl7Table, localCode);
        }
        catch (NullPointerException npe) {
            if (this.throwIfNoMatch)
                throw new HL7Exception(
                    "No interface mapping for the local code "
                        + localCode
                        + " for HL7 table "
                        + hl7Table
                        + " for the interface '"
                        + interfaceName
                        + "'",
                    ErrorCode.TABLE_VALUE_NOT_FOUND);
        }
        return interfaceCode;
    }

    /**
     * Determines what happens if no matching code is found during a lookup.  If set to true,
     * an HL7Exception is thrown if there is no match.  If false, null is returned.  The default
     * is false.
     */
    public void throwExceptionIfNoMatch(boolean throwException) {
        this.throwIfNoMatch = throwException;
    }

    /**
     * Test harness.
     */
    public static void main(String[] args) {
        try {
            //FileCodeMapper mapper = new FileCodeMapper();
            CodeMapper.getInstance().throwExceptionIfNoMatch(true);
            System.out.println("Local code for M is " + CodeMapper.getLocal("test", 1, "M"));
            System.out.println("Interface code for female is " + CodeMapper.getInt("test", 1, "female"));

        }
        catch (HL7Exception e) {
            e.printStackTrace();
        }
    }

}