/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You 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.apache.tools.ant.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Properties;

import org.apache.tools.ant.MagicTestNames;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;

import static org.apache.tools.ant.util.FileUtils.readFully;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.not;
import static org.hamcrest.Matchers.startsWith;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;

public class LayoutPreservingPropertiesTest {

    @Rule
    public TemporaryFolder folder = new TemporaryFolder();

    private static final String ROOT = System.getProperty(MagicTestNames.TEST_ROOT_DIRECTORY);

    private LayoutPreservingProperties lpf;

    private File tmp;

    @Before
    public void setUp() throws IOException {
        lpf = new LayoutPreservingProperties();
        tmp = folder.newFile("tmp.properties");
    }
    /**
     * Tests that a properties file read by the
     * LayoutPreservingPropertiesFile and then saves the properties in
     * it.
     */
    @Test
    public void testPreserve() throws Exception {
        File simple = new File(ROOT, "src/etc/testcases/util/simple.properties");
        FileInputStream fis = new FileInputStream(simple);
        lpf.load(fis);

        lpf.saveAs(tmp);

        // now compare original and tmp for property equivalence
        Properties originalProps = new Properties();
        originalProps.load(new FileInputStream(simple));

        Properties tmpProps = new Properties();
        tmpProps.load(new FileInputStream(tmp));

        assertEquals("properties corrupted", originalProps, tmpProps);

        // and now make sure that the comments made it into the new file
        String s = readFile(tmp);
        assertThat("missing comment", s, containsString(("# a comment")));
        assertThat("missing comment", s, containsString(("! more comment")));
    }

    /**
     * Tests that names and value are properly escaped when being
     * written out.
     */
    @Test
    public void testEscaping() throws Exception {
        lpf.setProperty(" prop one ", "  leading and trailing spaces ");
        lpf.setProperty("prop\ttwo", "contains\ttab");
        lpf.setProperty("prop\nthree", "contains\nnewline");
        lpf.setProperty("prop\rfour", "contains\rcarriage return");
        lpf.setProperty("prop\ffive", "contains\fform feed");
        lpf.setProperty("prop\\six", "contains\\backslash");
        lpf.setProperty("prop:seven", "contains:colon");
        lpf.setProperty("prop=eight", "contains=equals");
        lpf.setProperty("prop#nine", "contains#hash");
        lpf.setProperty("prop!ten", "contains!exclamation");

        lpf.saveAs(tmp);

        // and check that the resulting file looks okay
        String s = readFile(tmp);

        assertThat(s, containsString("\\ prop\\ one\\ =\\ \\ leading and trailing spaces "));
        assertThat(s, containsString("prop\\ttwo=contains\\ttab"));
        assertThat(s, containsString("prop\\nthree=contains\\nnewline"));
        assertThat(s, containsString("prop\\rfour=contains\\rcarriage return"));
        assertThat(s, containsString("prop\\\\six=contains\\\\backslash"));
        assertThat(s, containsString("prop\\:seven=contains\\:colon"));
        assertThat(s, containsString("prop\\=eight=contains\\=equals"));
        assertThat(s, containsString("prop\\#nine=contains\\#hash"));
        assertThat(s, containsString("prop\\!ten=contains\\!exclamation"));
    }

    /**
     * Tests that properties are correctly indexed, so that when we set
     * an existing property, it updates the logical line, and it doesn't
     * append a new one.
     */
    @Test
    public void testOverwrite() throws Exception {
        File unusual = new File(ROOT, "src/etc/testcases/util/unusual.properties");
        FileInputStream fis = new FileInputStream(unusual);
        lpf.load(fis);

        lpf.setProperty(" prop one ", "new one");
        lpf.setProperty("prop\ttwo", "new two");
        lpf.setProperty("prop\nthree", "new three");

        lpf.saveAs(tmp);

        // and check that the resulting file looks okay
        String s = readFile(tmp);

        assertThat(s, not(containsString("\\ prop\\ one\\ =\\ \\ leading and trailing spaces ")));
        assertThat(s, containsString("\\ prop\\ one\\ =new one"));
        assertThat(s, not(containsString("prop\\ttwo=contains\\ttab")));
        assertThat(s, containsString("prop\\ttwo=new two"));
        assertThat(s, not(containsString("prop\\nthree=contains\\nnewline")));
        assertThat(s, containsString("prop\\nthree=new three"));
    }

    @Test
    public void testStoreWithHeader() throws Exception {
        File simple = new File(ROOT, "src/etc/testcases/util/simple.properties");
        FileInputStream fis = new FileInputStream(simple);
        lpf.load(fis);

        try (FileOutputStream fos = new FileOutputStream(tmp)) {
            lpf.store(fos, "file-header");
        }

        // and check that the resulting file looks okay
        assertThat("should have had header ", readFile(tmp), startsWith("#file-header"));
    }

    @Test
    public void testClear() throws Exception {
        File simple = new File(ROOT, "src/etc/testcases/util/simple.properties");
        FileInputStream fis = new FileInputStream(simple);
        lpf.load(fis);

        lpf.clear();

        lpf.saveAs(tmp);

        // and check that the resulting file looks okay
        String s = readFile(tmp);

        assertThat("should have had no properties ", s, not(containsString(("prop.alpha"))));
        assertThat("should have had no properties ", s, not(containsString(("prop.beta"))));
        assertThat("should have had no properties ", s, not(containsString(("prop.gamma"))));

        assertThat("should have had no comments", s, not(containsString(("# a comment"))));
        assertThat("should have had no comments", s, not(containsString(("! more comment"))));
        assertThat("should have had no comments", s, not(containsString(("# now a line wrapping one"))));
    }

    @Test
    public void testRemove() throws Exception {
        File simple = new File(ROOT, "src/etc/testcases/util/simple.properties");
        FileInputStream fis = new FileInputStream(simple);
        lpf.load(fis);

        lpf.remove("prop.beta");

        lpf.saveAs(tmp);

        // and check that the resulting file looks okay
        String s = readFile(tmp);

        assertThat("should not have had prop.beta", s, not(containsString(("prop.beta"))));
        assertThat("should have had prop.beta's comment", s, containsString("! more comment"));
    }

    @Test
    public void testRemoveWithComment() throws Exception {
        File simple = new File(ROOT, "src/etc/testcases/util/simple.properties");
        FileInputStream fis = new FileInputStream(simple);
        lpf.load(fis);

        lpf.setRemoveComments(true);

        lpf.remove("prop.beta");

        lpf.saveAs(tmp);

        // and check that the resulting file looks okay
        String s = readFile(tmp);

        assertThat("should not have had prop.beta", s, not(containsString(("prop.beta"))));
        assertThat("should not have had prop.beta's comment", s, not(containsString(("! more comment"))));
    }

    @Test
    public void testClone() throws Exception {
        File simple = new File(ROOT, "src/etc/testcases/util/simple.properties");
        FileInputStream fis = new FileInputStream(simple);
        lpf.load(fis);

        LayoutPreservingProperties lpfClone = (LayoutPreservingProperties) lpf.clone();

        lpfClone.setProperty("prop.new", "a new property");
        lpfClone.setProperty("prop.beta", "a new value for beta");

        assertEquals("size of original is wrong", 3, lpf.size());
        assertEquals("size of clone is wrong", 4, lpfClone.size());

        lpf.saveAs(tmp);
        String s1 = readFile(tmp);

        File tmpClone = folder.newFile("tmp-clone.properties");
        lpfClone.saveAs(tmpClone);
        String s2 = readFile(tmpClone);

        // check original is untouched
        assertThat("should have had 'simple'", s1, containsString(("simple")));
        assertThat("should not have had prop.new", s1, not(containsString(("prop.new"))));

        // check clone has the changes
        assertThat("should have had 'a new value for beta'", s2, containsString(("a new value for beta")));
        assertThat("should have had prop.new", s2, containsString(("prop.new")));
    }

    @Test
    public void testPreserveEscapeName() throws Exception {
        File unusual = new File(ROOT, "src/etc/testcases/util/unusual.properties");
        FileInputStream fis = new FileInputStream(unusual);
        lpf.load(fis);

        lpf.setProperty("prop:seven", "new value for seven");
        lpf.setProperty("prop=eight", "new value for eight");
        lpf.setProperty("prop eleven", "new value for eleven");

        lpf.setProperty("alpha", "new value for alpha");
        lpf.setProperty("beta", "new value for beta");

        lpf.saveAs(tmp);

        // and check that the resulting file looks okay
        String s = readFile(tmp);

        assertThat(s, containsString("prop\\:seven=new value for seven"));
        assertThat(s, containsString("prop\\=eight=new value for eight"));
        assertThat(s, containsString("prop\\ eleven=new value for eleven"));
        assertThat(s, containsString("alpha=new value for alpha"));
        assertThat(s, containsString("beta=new value for beta"));

        assertThat(s, not(containsString("prop\\:seven=contains\\:colon")));
        assertThat(s, not(containsString("prop\\=eight=contains\\=equals")));
        assertThat(s, not(containsString("alpha:set with a colon")));
        assertThat(s, not(containsString("beta set with a space")));
    }

    private static String readFile(File f) throws IOException {
        try (InputStreamReader isr = new InputStreamReader(new FileInputStream(f))) {
            return readFully(isr);
        }
    }
}
