/*
    * Copyright 2005,2009 Ivan SZKIBA
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.ini4j;
  
  import org.ini4j.spi.IniFormatter;
  import org.ini4j.spi.IniHandler;
  import org.ini4j.spi.IniParser;
  import org.ini4j.spi.RegBuilder;
  
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.InterruptedIOException;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.Reader;
  import java.io.Writer;
  
  import java.net.URL;
  
  public class Reg extends BasicRegistry implements Registry, Persistable, Configurable
  {
      private static final long serialVersionUID = -1485602876922985912L;
      protected static final String DEFAULT_SUFFIX = ".reg";
      protected static final String TMP_PREFIX = "reg-";
      private static final int STDERR_BUFF_SIZE = 8192;
      private static final String PROP_OS_NAME = "os.name";
      private static final boolean WINDOWS = Config.getSystemProperty(PROP_OS_NAME, "Unknown").startsWith("Windows");
      private static final char CR = '\r';
      private static final char LF = '\n';
      private Config _config;
      private File _file;
  
      public Reg()
      {
          Config cfg = Config.getGlobal().clone();
  
          cfg.setEscape(false);
          cfg.setGlobalSection(false);
          cfg.setEmptyOption(true);
          cfg.setMultiOption(true);
          cfg.setStrictOperator(true);
          cfg.setEmptySection(true);
          cfg.setPathSeparator(KEY_SEPARATOR);
          cfg.setFileEncoding(FILE_ENCODING);
          cfg.setLineSeparator(LINE_SEPARATOR);
          _config = cfg;
      }
  
      public Reg(String registryKey) throws IOException
      {
          this();
          read(registryKey);
      }
  
      public Reg(File input) throws IOException, InvalidFileFormatException
      {
          this();
          _file = input;
          load();
      }
  
      public Reg(URL input) throws IOException, InvalidFileFormatException
      {
          this();
          load(input);
      }
  
      public Reg(InputStream input) throws IOException, InvalidFileFormatException
      {
          this();
          load(input);
      }
  
      public Reg(Reader input) throws IOException, InvalidFileFormatException
      {
          this();
          load(input);
      }
  
      public static boolean isWindows()
      {
          return WINDOWS;
     }
 
     @Override public Config getConfig()
     {
         return _config;
     }
 
     public void setConfig(Config value)
     {
         _config = value;
     }
 
     @Override public File getFile()
     {
         return _file;
     }
 
     @Override public void setFile(File value)
     {
         _file = value;
     }
 
     @Override public void load() throws IOException, InvalidFileFormatException
     {
         if (_file == null)
         {
             throw new FileNotFoundException();
         }
 
         load(_file);
     }
 
     @Override public void load(InputStream input) throws IOException, InvalidFileFormatException
     {
         load(new InputStreamReader(input, getConfig().getFileEncoding()));
     }
 
     @Override public void load(URL input) throws IOException, InvalidFileFormatException
     {
         load(new InputStreamReader(input.openStream(), getConfig().getFileEncoding()));
     }
 
     @Override public void load(Reader input) throws IOException, InvalidFileFormatException
     {
         int newline = 2;
         StringBuilder buff = new StringBuilder();
 
         for (int c = input.read(); c != -1; c = input.read())
         {
             if (c == LF)
             {
                 newline--;
                 if (newline == 0)
                 {
                     break;
                 }
             }
             else if ((c != CR) && (newline != 1))
             {
                 buff.append((char) c);
             }
         }
 
         if (buff.length() == 0)
         {
             throw new InvalidFileFormatException("Missing version header");
         }
 
         if (!buff.toString().equals(getVersion()))
         {
             throw new InvalidFileFormatException("Unsupported version: " + buff.toString());
         }
 
         IniParser.newInstance(getConfig()).parse(input, newBuilder());
     }
 
     @Override public void load(File input) throws IOException, InvalidFileFormatException
     {
         load(input.toURI().toURL());
     }
 
     public void read(String registryKey) throws IOException
     {
         File tmp = createTempFile();
 
         try
         {
             regExport(registryKey, tmp);
             load(tmp);
         }
         finally
         {
             tmp.delete();
         }
     }
 
     @Override public void store() throws IOException
     {
         if (_file == null)
         {
             throw new FileNotFoundException();
         }
 
         store(_file);
     }
 
     @Override public void store(OutputStream output) throws IOException
     {
         store(new OutputStreamWriter(output, getConfig().getFileEncoding()));
     }
 
     @Override public void store(Writer output) throws IOException
     {
         output.write(getVersion());
         output.write(getConfig().getLineSeparator());
         output.write(getConfig().getLineSeparator());
         store(IniFormatter.newInstance(output, getConfig()));
     }
 
     @Override public void store(File output) throws IOException
     {
         OutputStream stream = new FileOutputStream(output);
 
         store(stream);
         stream.close();
     }
 
     public void write() throws IOException
     {
         File tmp = createTempFile();
 
         try
         {
             store(tmp);
             regImport(tmp);
         }
         finally
         {
             tmp.delete();
         }
     }
 
     protected IniHandler newBuilder()
     {
         return RegBuilder.newInstance(this);
     }
 
     @Override boolean isTreeMode()
     {
         return getConfig().isTree();
     }
 
     @Override char getPathSeparator()
     {
         return getConfig().getPathSeparator();
     }
 
     @Override boolean isPropertyFirstUpper()
     {
         return getConfig().isPropertyFirstUpper();
     }
 
     void exec(String[] args) throws IOException
     {
         Process proc = Runtime.getRuntime().exec(args);
 
         try
         {
             int status = proc.waitFor();
 
             if (status != 0)
             {
                 Reader in = new InputStreamReader(proc.getErrorStream());
                 char[] buff = new char[STDERR_BUFF_SIZE];
                 int n = in.read(buff);
 
                 in.close();
                 throw new IOException(new String(buff, 0, n).trim());
             }
         }
         catch (InterruptedException x)
         {
             throw (IOException) (new InterruptedIOException().initCause(x));
         }
     }
 
     private File createTempFile() throws IOException
     {
         File ret = File.createTempFile(TMP_PREFIX, DEFAULT_SUFFIX);
 
         ret.deleteOnExit();
 
         return ret;
     }
 
     private void regExport(String registryKey, File file) throws IOException
     {
         requireWindows();
         exec(new String[] { "cmd", "/c", "reg", "export", registryKey, file.getAbsolutePath() });
     }
 
     private void regImport(File file) throws IOException
     {
         requireWindows();
         exec(new String[] { "cmd", "/c", "reg", "import", file.getAbsolutePath() });
     }
 
     private void requireWindows()
     {
         if (!WINDOWS)
         {
             throw new UnsupportedOperationException("Unsupported operating system or runtime environment");
         }
     }
 }