package org.webslinger.util;

 import java.io.BufferedReader;

 import java.io.FileInputStream;

 import java.io.InputStream;

 import java.io.InputStreamReader;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.io.OutputStreamWriter;

 import java.io.Reader;

 import java.io.Writer;

 import java.net.URL;

 import java.util.Enumeration;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.Map;

 import java.util.StringTokenizer;

 import org.webslinger.io.Charsets;

 public class MimeTypes implements MimeTypeLookup {

     protected final HashMap<String, MimeTypeEntryImpl> byExtension = new HashMap<String, MimeTypeEntryImpl>();

     protected final HashMap<String, MimeTypeEntryImpl> byMimeType = new HashMap<String, MimeTypeEntryImpl>();

     public static void main(String[] args) throws IOException {

         MimeTypes mimeTypes = new MimeTypes();

         mimeTypes.load(new FileInputStream(args[0]), true);

     }

     public void load(Enumeration<URL> urls) throws IOException {

         while (urls.hasMoreElements()) {

             URL url = urls.nextElement();

             load(url.openStream());

         }

     }

     public void load(InputStream in) throws IOException {

         load(in, true);

     }

     public void load(InputStream in, boolean close) throws IOException {

         load(new InputStreamReader(in, Charsets.UTF8), close);

     }

     public void load(InputStream in, boolean close, boolean clear) throws IOException {

         load(new InputStreamReader(in, Charsets.UTF8), close, true);

     }

     public void load(Reader in) throws IOException {

         load(in, true);

     }

     public void load(Reader in, boolean close) throws IOException {

         load(in, close, true);

     }

     public void load(Reader in, boolean close, boolean clear) throws IOException {

         if (clear) {

             byExtension.clear();

             byMimeType.clear();

         }

         BufferedReader br = in instanceof BufferedReader ? (BufferedReader) in : new BufferedReader(in);

         String line;

         while ((line = br.readLine()) != null) {

             line = line.trim();

             int hash = line.indexOf("#");

             if (hash != -1) line = line.substring(0, hash);

             if (line.length() == 0) continue;

             String[] parts = line.split("[ \t]+");

             String mimeType = parts[0];

             MimeTypeEntryImpl newEntry, oldEntry;

             if (parts.length > 1) {

                 String[] extensions = new String[parts.length - 1];

                 System.arraycopy(parts, 1, extensions, 0, extensions.length);

                 newEntry = new MimeTypeEntryImpl(mimeType, extensions);

             } else {

                 newEntry = new MimeTypeEntryImpl(mimeType);

             }

             oldEntry = byMimeType.put(mimeType, newEntry);

             if (oldEntry != null) oldEntry.removeAll();

             for (String extension: newEntry.getExtensions()) {

                 oldEntry = byExtension.put(extension, newEntry);

                 if (oldEntry != null) oldEntry.removeExtension(extension);

             }

         }

         if (close) in.close();

     }

     public void write(OutputStream out, boolean close) throws IOException {

         write(new OutputStreamWriter(out, Charsets.UTF8), close);

     }

     public void write(Writer out, boolean close) throws IOException {

         StringBuilder line = new StringBuilder();

         for (MimeTypeEntry entry: byMimeType.values()) {

             String mimeType = entry.getMimeType();

             line.append(mimeType);

             int length = mimeType.length();

             String[] extensions = entry.getExtensions();

             for (int i = 0; i < extensions.length; i++) {

                 if (i == 0 && length < 48) {

                     while (length < 48) {

                         line.append('\t');

                         length += 8;

                     }

                 } else {

                     line.append(' ');

                 }

                 line.append(extensions[i]);

             }

             line.append('\n');

             out.write(line.toString());

             line.setLength(0);

         }

         if (close) out.close();

     }

     public String getMimeType(String extension) {

         MimeTypeEntry entry = byExtension.get(extension);

         return entry != null ? entry.getMimeType() : null;

     }

     public String[] getExtensions(String mimeType) {

         MimeTypeEntry entry = byMimeType.get(mimeType);

         return entry != null ? entry.getExtensions() : null;

     }

     public String getPrimaryExtension(String mimeType) {

         MimeTypeEntry entry = byMimeType.get(mimeType);

         return entry != null ? entry.getPrimaryExtension() : null;

     }

     public MimeTypeEntry addMimeType(String mimeType) {

         MimeTypeEntryImpl entry = byMimeType.get(mimeType);

         if (entry == null) {

             entry = new MimeTypeEntryImpl(mimeType);

             byMimeType.put(mimeType, entry);

         }

         return entry;

     }

     public MimeTypeEntry addExtension(String mimeType, String extension) {

         MimeTypeEntryImpl entry = byMimeType.get(mimeType);

         if (entry == null) {

             entry = new MimeTypeEntryImpl(mimeType);

             byMimeType.put(mimeType, entry);

         }

         entry.addExtension(extension);

         return entry;

     }

     public String toString() {

         StringBuilder sb = new StringBuilder();

         Iterator<MimeTypeEntryImpl> it = byMimeType.values().iterator();

         while (it.hasNext()) {

             MimeTypeEntry entry = it.next();

             sb.append(entry);

             if (it.hasNext()) sb.append("\n\t");

         }

         return sb.toString();

     }

     public interface MimeTypeEntry {

         String getMimeType();

         String[] getExtensions();

         String getPrimaryExtension();

         void addExtension(String extension);

         void removeExtension(String extension);

         void setPrimaryExtension(String extension);

     }

     protected class MimeTypeEntryImpl implements MimeTypeEntry {

         protected final String mimeType;

         protected String[] extensions;

         protected MimeTypeEntryImpl(String mimeType) {

             this(mimeType, new String[0]);

         }

         protected MimeTypeEntryImpl(String mimeType, String[] extensions) {

             this.mimeType = mimeType;

             this.extensions = extensions;

         }

         public String getMimeType() {

             return mimeType;

         }

         public String[] getExtensions() {

             return extensions;

         }

         public String getPrimaryExtension() {

             return extensions.length > 0 ? extensions[0] : null;

         }

         public void removeExtension(String extension) {

             for (int i = 0; i < extensions.length; i++) {

                 if (extensions[i].equals(extension)) {

                     String[] newExtensions = new String[extensions.length - 1];

                     System.arraycopy(extensions, 0, newExtensions, 0, i);

                     if (i + 1 < extensions.length) System.arraycopy(extensions, i + 1, newExtensions, i, newExtensions.length - i);

                     extensions = newExtensions;

                     MimeTypeEntryImpl existing = byExtension.get(extension);

                     if (existing != this) return;

                     byExtension.remove(extension);

                     break;

                 }

             }

         }

         public void setPrimaryExtension(String extension) {

             for (int i = 0; i < extensions.length; i++) {

                 if (extensions[i].equals(extension)) {

                     if (i != 0) {

                         String tmp = extensions[0];

                         extensions[0] = extensions[i];

                         extensions[i] = tmp;

                     }

                     return;

                 }

             }

             throw new IllegalArgumentException("Extension(" + extension + ") not found for mime type(" + getMimeType() + ")");

         }

         public void addExtension(String extension) {

             for (String ext: extensions) {

                 if (ext.equals(extension)) return;

             }

             String[] newExtensions = new String[extensions.length + 1];

             System.arraycopy(extensions, 0, newExtensions, 0, extensions.length);

             newExtensions[extensions.length] = extension;

             extensions = newExtensions;

             MimeTypeEntryImpl old = byExtension.put(extension, this);

             if (old == null) return;

             old.removeExtension(extension);

         }

         protected void removeAll() {

             for (String extension: extensions) {

                 byExtension.remove(extension);

             }

             extensions = new String[0];

         }

         public String toString() {

             StringBuilder sb = new StringBuilder();

             sb.append("MT(").append(getMimeType());

             String[] extensions = getExtensions();

             if (extensions.length > 0) {

                 sb.append(':');

                 for (int i = 0; i < extensions.length; i++) {

                     if (i != 0) sb.append(' ');

                     sb.append(extensions[i]);

                 }

             }

             sb.append(')');

             return sb.toString();

         }

     }

 }