package org.jgroups.protocols;

import org.jgroups.Address;
import org.jgroups.Event;
import org.jgroups.PhysicalAddress;
import org.jgroups.View;
import org.jgroups.annotations.MBean;
import org.jgroups.annotations.ManagedOperation;
import org.jgroups.annotations.Property;
import org.jgroups.stack.Protocol;
import org.jgroups.util.Streamable;
import org.jgroups.util.Tuple;
import org.jgroups.util.UUID;
import org.jgroups.util.Util;

import java.io.*;
import java.nio.channels.FileChannel;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * Persistent Discovery Cache. Caches mapping between logical and physical addresses on disk, merges them with the
 * results of the get physical address(es) events.
 * This is done by intercepting the get and set physical address(es) event. Needs to be placed between the transport and
 * the discovery protocol. The disk cache stores each mapping in a separate file, named by the logical address.
 *
 * @author Bela Ban
 * @since  3.3
 */
@MBean(description="Persistent Discovery Cache. Caches discovery information on disk.")
public class PDC extends Protocol {
    protected final ConcurrentMap<Address,PhysicalAddress> cache=new ConcurrentHashMap<Address,PhysicalAddress>();

    /* -----------------------------------------    Properties     ----------------------------------------------- */
    @Property(description="The absolute path of the directory for the disk cache. The mappings will be stored as " +
      "individual files in this directory")
    protected String              cache_dir=File.separator + "tmp" + File.separator + "jgroups";



    /* --------------------------------------------- Fields ------------------------------------------------------ */
    protected static final String SUFFIX=".node";
    protected File                root_dir;
    protected FilenameFilter      filter;
    protected Address             local_addr;





    @ManagedOperation(description="Prints the contents of the address-physical address mappings")
    public String printCache() {
        StringBuilder sb=new StringBuilder();
        for(Map.Entry<Address,PhysicalAddress> entry: cache.entrySet()) {
            sb.append(entry.getKey() + ": " + entry.getValue() + "\n");
        }
        return sb.toString();
    }


    public void init() throws Exception {
        super.init();
        createDiskCacheFile();
        readCacheFromDisk(); // populates the cache from disk (if the file is present found)
    }


    public Object down(Event evt) {
        switch(evt.getType()) {
            case Event.GET_PHYSICAL_ADDRESS:
                Address logical_addr=(Address)evt.getArg();
                Object addr=down_prot.down(evt);
                return addr != null? addr : cache.get(logical_addr);

            case Event.GET_PHYSICAL_ADDRESSES:
                Collection<PhysicalAddress> addrs=(Collection<PhysicalAddress>)down_prot.down(evt);
                Collection<PhysicalAddress> tmp=new HashSet<PhysicalAddress>(addrs);
                tmp.addAll(cache.values());
                return tmp;

            case Event.GET_LOGICAL_PHYSICAL_MAPPINGS:
                Map<Address,PhysicalAddress> map=(Map<Address, PhysicalAddress>)down_prot.down(evt);
                Map<Address,PhysicalAddress> new_map=new HashMap<Address,PhysicalAddress>(map);
                new_map.putAll(cache);
                return new_map;

            case Event.SET_PHYSICAL_ADDRESS:
                Tuple<Address,PhysicalAddress> new_val=(Tuple<Address, PhysicalAddress>)evt.getArg();
                if(new_val != null) {
                    cache.put(new_val.getVal1(), new_val.getVal2());
                    writeNodeToDisk(new_val.getVal1(), new_val.getVal2());
                }
                break;
            case Event.REMOVE_ADDRESS:
                Address tmp_addr=(Address)evt.getArg();
                if(cache.remove(tmp_addr) != null)
                    removeNodeFromDisk(tmp_addr);
                break;
            case Event.SET_LOCAL_ADDRESS:
                local_addr=(Address)evt.getArg();
                break;
            case Event.VIEW_CHANGE:
                List<Address> members=((View)evt.getArg()).getMembers();
                for(Address mbr: cache.keySet()) {
                    if(!members.contains(mbr)) {
                        cache.remove(mbr);
                        removeNodeFromDisk(mbr);
                    }
                }
                break;
        }
        return down_prot.down(evt);
    }



    protected void createDiskCacheFile() throws IOException {
        root_dir=new File(this.cache_dir);
        if(root_dir.exists()) {
            if(!root_dir.isDirectory())
                throw new IllegalArgumentException("location " + root_dir.getPath() + " is not a directory");
        }
        else {
            root_dir.mkdirs();
        }
        if(!root_dir.exists())
            throw new IllegalArgumentException("location " + root_dir.getPath() + " could not be accessed");

        filter=new FilenameFilter() {
            public boolean accept(File dir, String name) {
                return name.endsWith(SUFFIX);
            }
        };
    }

    /** Reads all mappings from disk */
    protected synchronized void readCacheFromDisk() {
        if(log.isDebugEnabled())
            log.debug("reading all mappings from disk cache " + root_dir);
        File[] files=root_dir.listFiles(filter);
        if(files == null)
            return;

        for(File file: files) {
            // implementing a simple spin lock doing a few attempts to read the file
            // this is done since the file may be written in concurrency and may therefore not be readable
            Mapping data=null;
            for(int i=0; i < 3; i++) {
                data=null;
                if(file.exists())
                    data=readAddressMapping(file);
                if(data != null)
                    break;
                else
                    Util.sleep(100);
            }

            if(data == null) {
                log.warn("failed parsing content in " + file.getAbsolutePath() + ": removing it ");
                deleteFile(file);
            }
            else {
                if(data != null && data.getLogicalAddr() != null && data.getPhysicalAddr() != null) {
                    cache.put(data.getLogicalAddr(), (PhysicalAddress)data.getPhysicalAddr());
                    if(data.getLogicalName() != null && UUID.get(data.getLogicalAddr()) == null)
                        UUID.add(data.getLogicalAddr(), data.getLogicalName());
                }
            }
        }
    }

    private synchronized Mapping readAddressMapping(File file) {
        DataInputStream in=null;
        try {
            in=new DataInputStream(new FileInputStream(file));
            Mapping mapping=new Mapping();
            mapping.readFrom(in);
            return mapping;
        }
        catch(Exception e) {
            log.debug("failed to read file : "+file.getAbsolutePath(), e);
            return null;
        }
        finally {
            Util.close(in);
        }
    }


    protected synchronized void writeNodeToDisk(Address logical_addr, PhysicalAddress physical_addr) {
        String filename=addressAsString(logical_addr);

        // first write all data to a temporary file
        // this is because the writing can be very slow under some circumstances
        File tmpFile=null, destination=null;
        try {
            tmpFile=writeToTempFile(root_dir, logical_addr, physical_addr, UUID.get(logical_addr));
            if(tmpFile == null)
                return;

            destination=new File(root_dir, filename + SUFFIX);

            //do a file move, this is much faster and could be considered atomic on most operating systems
            FileChannel src_ch=new FileInputStream(tmpFile).getChannel();
            FileChannel dest_ch=new FileOutputStream(destination).getChannel();
            src_ch.transferTo(0,src_ch.size(),dest_ch);
            src_ch.close();
            dest_ch.close();
            if(log.isTraceEnabled())
                log.trace("Moved: " + tmpFile.getName() + "->" + destination.getName());
        }
        catch(Exception ioe) {
            log.error("attempt to move failed at: " + tmpFile.getName() + "->" + destination.getName(), ioe);
        }
        finally {
            deleteFile(tmpFile);
        }
    }

    /**
     * Writes the data to a temporary file.<br>
     * The file is stored in the same directory as the other cluster files but is given the <tt>.tmp</tmp> suffix
     * @param dir The disk cache root dir
     * @param logical_addr The logical address
     * @param physical_addr The physical address
     * @return
     */
    protected File writeToTempFile(File dir, Address logical_addr, Address physical_addr, String logical_name) throws Exception {
        DataOutputStream out=null;

        File file=null;
        String filename=null;
        try {
            file=File.createTempFile("temp", null, dir);
            filename=file.getName();
            out=new DataOutputStream(new FileOutputStream(file));
            Util.writeAddress(logical_addr, out);
            Util.writeAddress(physical_addr, out);
            Util.writeString(logical_name, out);
            Util.close(out);
            if(log.isTraceEnabled())
                log.trace("Stored temporary file: " + file.getAbsolutePath());
        }
        catch(Exception e) {
            Util.close(out);
            log.error("Failed to write temporary file: " + filename, e);
            deleteFile(file);
            return null;
        }
        return file;
    }


    protected synchronized void removeNodeFromDisk(Address logical_addr) {
        String filename=addressAsString(logical_addr);
        deleteFile(new File(root_dir, filename + SUFFIX));
    }


    protected static String addressAsString(Address address) {
        if(address == null)
            return "";
        if(address instanceof UUID)
            return ((UUID) address).toStringLong();
        return address.toString();
    }



    /**
     * Attempts to delete the provided file.<br>
     * Logging is performed on the result
     * @param file
     * @return
     */
    protected boolean deleteFile(File file) {
        boolean result = true;
        if(log.isTraceEnabled())
            log.trace("Attempting to delete file : "+file.getAbsolutePath());

        if(file != null && file.exists()) {
            try {
                result=file.delete();
                if(log.isTraceEnabled())
                    log.trace("Deleted file result: "+file.getAbsolutePath() +" : "+result);
            }
            catch(Throwable e) {
                log.error("Failed to delete file: " + file.getAbsolutePath(), e);
            }
        }
        return result;
    }


    protected static class Mapping implements Streamable {
        protected Address         logical_addr;
        protected Address         physical_addr;
        protected String          logical_name;

        public Mapping() {
        }

        public Mapping(Address logical_addr, PhysicalAddress physical_addr, String logical_name) {
            this.logical_addr=logical_addr;
            this.physical_addr=physical_addr;
            this.logical_name=logical_name;
        }

        public Address  getLogicalAddr()  {return logical_addr;}
        public Address  getPhysicalAddr() {return physical_addr;}
        public String   getLogicalName()  {return logical_name;}

        public void writeTo(DataOutput out) throws Exception {
            Util.writeAddress(logical_addr, out);
            Util.writeAddress(physical_addr, out);
            Util.writeString(logical_name, out);
        }

        public void readFrom(DataInput in) throws Exception {
            logical_addr=Util.readAddress(in);
            physical_addr=Util.readAddress(in);
            logical_name=Util.readString(in);
        }

        public String toString() {
            return logical_addr + ": " + physical_addr + " (logical name=" + logical_name + ")";
        }
    }
}
