package org.webslinger.commons.vfs.tests;

 import org.webslinger.httpunit.WebslingerTestCase;

 import java.io.EOFException;

 import java.io.File;

 import java.io.InputStream;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.util.Collection;

 import java.util.LinkedHashMap;

 import org.apache.commons.vfs.FileContent;

 import org.apache.commons.vfs.FileObject;

 import org.apache.commons.vfs.FileSystem;

 import org.apache.commons.vfs.FileSystemOptions;

 import org.apache.commons.vfs.RandomAccessContent;

 import org.apache.commons.vfs.Selectors;

 import org.apache.commons.vfs.impl.StandardFileSystemManager;

 import org.apache.commons.vfs.util.RandomAccessMode;

 import org.webslinger.containers.TestContainer;

 import org.webslinger.commons.vfs.VFSUtil;

 import org.webslinger.commons.vfs.cow.COWConfigBuilder;

 import org.webslinger.commons.vfs.cow.COWFileSystem;

 import org.webslinger.commons.vfs.cow.COWFsck;

 import org.webslinger.commons.vfs.operations.COWStateOperation;

 import org.webslinger.commons.vfs.operations.SymlinkOperation;

 import org.webslinger.commons.vfs.tests.COWFileMapping;

 import org.webslinger.commons.vfs.tests.COWTester;

 import org.webslinger.commons.vfs.tests.SymlinkTester;

 import org.webslinger.commons.vfs.tests.TestUtil;

 import org.webslinger.io.IOUtil;

 public class TestCow extends TestContainer.TestContainerTestCase {

     protected StandardFileSystemManager sfsm;

     protected FileObject root;

     public TestCow(String name) {

         super(name);

     }

     protected void setUp() throws Exception {

         super.setUp();

         FileSystemOptions options = new FileSystemOptions();

         COWConfigBuilder.getInstance().setCOWEntryFactory(options, new COWFileSystem.DefaultCOWEntryFactory());

         sfsm = VFSUtil.createStandardFileSystemManager();

         root = sfsm.createVirtualFileSystem(VFSUtil.toFileObject(sfsm, new File(getTestLocation(), getName()), options));

         root.delete(Selectors.SELECT_ALL);

     }

     protected void tearDown() throws Exception {

         root.delete(Selectors.SELECT_ALL);

         super.tearDown();

     }

     protected SymlinkOperation getSymlinkOperation(FileObject file) throws Exception {

         return VFSUtil.getOperation(file, SymlinkOperation.class);

     }

     protected SymlinkOperation getSymlinkOperation(FileSystem fs, String path) throws Exception {

         return VFSUtil.getOperation(fs, path, SymlinkOperation.class);

     }

     public void testCOWDirectory() throws Exception {

         new COWTester(

             root,

             "cow",

             true,

             new COWFileMapping("view", "layer1", "FileInLayer1"),

             new COWFileMapping("view", "layer2", "Layer2File"),

             new COWFileMapping("view", "layer3", "FileForTheThirdLayer")

         ).doTest();

     }

     public void testCOWFile() throws Exception {

         new COWTester(

             root,

             "cow",

             false,

             new COWFileMapping("view/FileInLayer1", "../layer1/FileInLayer1", "FileInLayer1"),

             new COWFileMapping("view/Layer2File", "../layer2/Layer2File", "Layer2File"),

             new COWFileMapping("view/FileForTheThirdLayer", "../layer3/FileForTheThirdLayer", "FileForTheThirdLayer")

         ).doTest();

     }

     public void testWsvfsDirectory() throws Exception {

         new COWTester(

             root,

             "wsvfs",

             true,

             new COWFileMapping("view", "layer1", "FileInLayer1"),

             new COWFileMapping("view", "layer2", "Layer2File"),

             new COWFileMapping("view", "layer3", "FileForTheThirdLayer")

         ).doTest();

     }

     public void testWsvfsFile() throws Exception {

         new COWTester(

             root,

             "wsvfs",

             false,

             new COWFileMapping("view/FileInLayer1", "../layer1/FileInLayer1", "FileInLayer1"),

             new COWFileMapping("view/Layer2File", "../layer2/Layer2File", "Layer2File"),

             new COWFileMapping("view/FileForTheThirdLayer", "../layer3/FileForTheThirdLayer", "FileForTheThirdLayer")

         ).doTest();

     }

     public void testSymlinks() throws Exception {

         new SymlinkTester(sfsm.createFileSystem("cow", root)).doTest();

     }

     public void testCOWStateReading() throws Exception {

         FileSystem cfs = sfsm.createFileSystem("cow", root).getFileSystem();

         FileObject cow = cfs.getRoot();

         VFSUtil.setString(

             root,

             ".cowstate.xml",

   "<state>\n"

 + " <item name=\"cow\">\n"

 + "  <base target=\"real/dir1\"/>\n"

 + "  <base target=\"real/dir2\"/>\n"

 + "  <base target=\"real/dir3\"/>\n"

 + " </item>\n"

 + "</state>\n"

         );

         VFSUtil.setString(

             root,

             "cow/.cowstate.xml",

   "<state>\n"

 + " <item name=\"link\" symlink=\"file3\"/>\n"

 + " <item name=\"file1\" deleted=\"true\"/>\n"

 + " <item name=\"fileN\">\n"

 + "  <base target=\"file2\"/>\n"

 + " </item>\n"

 + "</state>\n"

         );

         VFSUtil.setString(root, "real/dir1/file1", "textual content");

         VFSUtil.setString(root, "real/dir2/file2", "bits and bytes");

         VFSUtil.setString(root, "real/dir3/file3", "letters and numbers");

         VFSUtil.setString(root, "cow/fileX", "on top");

         VFSUtil.setString(root, "cow/file2", "new content");

         // Check real files

         assertTrue("real/dir1/file1 exists", cow.resolveFile("real/dir1/file1").exists());

         assertEquals("real/dir1/file1 content", "textual content", VFSUtil.getString(root, "real/dir1/file1"));

         FileObject[] children = cow.resolveFile("real/dir1").getChildren();

         assertEquals("real/dir1 number of children", 1, children.length);

         assertEquals("real/dir1 single child", "file1", children[0].getName().getBaseName());

         assertTrue("real/dir2/file2 exists", cow.resolveFile("real/dir2/file2").exists());

         assertEquals("real/dir2/file2 content", "bits and bytes", VFSUtil.getString(root, "real/dir2/file2"));

         children = cow.resolveFile("real/dir2").getChildren();

         assertEquals("real-dir2 number of children", 1, children.length);

         assertEquals("real-dir2 single child", "file2", children[0].getName().getBaseName());

         assertTrue("real/dir3/file3 exists", cow.resolveFile("real/dir3/file3").exists());

         assertEquals("real/dir3/file3 content", "letters and numbers", VFSUtil.getString(root, "real/dir3/file3"));

         children = cow.resolveFile("real/dir3").getChildren();

         assertEquals("real/dir3 number of children", 1, children.length);

         assertEquals("real/dir3 single child", "file3", children[0].getName().getBaseName());

         // Check cow resolution

         children = cow.resolveFile("cow").getChildren();

         assertEquals("top level children count", 5, children.length);

         int matchedBits = 0;

         int matchedCount = 0;

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

             String base = children[i].getName().getBaseName();

             if (base.equals("file2")) {

                 matchedBits |= 1;

                 matchedCount++;

             } else if (base.equals("file3")) {

                 matchedBits |= 2;

                 matchedCount++;

             } else if (base.equals("fileN")) {

                 matchedBits |= 4;

                 matchedCount++;

             } else if (base.equals("fileX")) {

                 matchedBits |= 8;

                 matchedCount++;

             } else if (base.equals("link")) {

                 matchedBits |= 16;

                 matchedCount++;

             } else {

                 fail("Found unknown child in cow(" + base + ")");

             }

         }

         assertEquals("found all children(bits)", 31, matchedBits);

         assertEquals("found all children(count)", 5, matchedCount);

         assertTrue("cow:cow/link exists", cow.resolveFile("cow/link").exists());

         assertEquals("cow/link content", "letters and numbers", VFSUtil.getString(cow, "cow/link"));

         assertFalse("real:cow/link does not exist", root.resolveFile("cow/link").exists());

         assertFalse("cow/file1 does not exist", cow.resolveFile("cow/file1").exists());

         assertTrue("cow/file2 exists", cow.resolveFile("cow/file2").exists());

         assertTrue("cow:cow/fileN exists", cow.resolveFile("cow/fileN").exists());

         assertEquals("cow/fileN content", "new content", VFSUtil.getString(cow, "cow/fileN"));

         assertFalse("real:cow/fileN does not exist", root.resolveFile("cow/fileN").exists());

         assertTrue("cow:cow/file3 exists", cow.resolveFile("cow/file3").exists());

         assertEquals("cow/file3 content", "letters and numbers", VFSUtil.getString(cow, "cow/file3"));

         assertFalse("real:cow/file3 does not exist", root.resolveFile("cow/file3").exists());

         VFSUtil.tree(cow, System.err);

     }

     public void testCOWFsck() throws Exception {

         final LinkedHashMap messages = new LinkedHashMap();

         COWFsck.MessageHandler messageHandler = new COWFsck.MessageHandler() {

             public void warn(FileObject file, int code, String message) {

                 addMessage("warn", file, code, message);

             }

             public void info(FileObject file, int code, String message) {

                 addMessage("info", file, code, message);

             }

             public void error(FileObject file, int code, String message) {

                 addMessage("error", file, code, message);

             }

             public void error(FileObject file, int code, String message, Exception e) {

                 addMessage("error", file, code, message);

             }

             protected void addMessage(String level, FileObject file, int code, String message) {

                 String key = level + ':' + code + ':' + message + ':' + file.getName().getPath();

                 Integer count = (Integer) messages.get(key);

                 messages.put(key, count == null ? Integer.valueOf(1) : Integer.valueOf(count.intValue() + 1));

             }

         };

         COWFsck fsck = new COWFsck(root, messageHandler);

         root.resolveFile("stale empty cow/.cow").createFolder();

         root.resolveFile("corrupted/cow as file/.cow").createFile();

         VFSUtil.touch(root.resolveFile("corrupted/symlink/.cow/deleted/linked-deleted-file"));

         VFSUtil.setString(root, "corrupted/symlink/.cow/link/linked-deleted-file", "target");

         VFSUtil.setString(root, "corrupted/undelete/not-deleted-file", "content");

         VFSUtil.touch(root.resolveFile("corrupted/undelete/.cow/deleted/not-deleted-file"));

         VFSUtil.touch(root.resolveFile("corrupted/nested-cow-dir/.cow/deleted/.cow/deleted"));

         VFSUtil.touch(root.resolveFile("corrupted/nested-cow-dir/.cow/link/.cow/link"));

         VFSUtil.touch(root.resolveFile("corrupted/nested-cow-dir/.cow/cow-links/.cow/cow-links"));

         VFSUtil.touch(root.resolveFile("corrupted/nested-cow-file/.cow/deleted/.cow"));

         VFSUtil.touch(root.resolveFile("corrupted/nested-cow-file/.cow/link/.cow"));

         VFSUtil.touch(root.resolveFile("corrupted/nested-cow-file/.cow/cow-links/.cow"));

         VFSUtil.touch(root.resolveFile("corrupted/nested-state/.cow/deleted/.cowstate.xml"));

         VFSUtil.touch(root.resolveFile("corrupted/nested-state/.cow/link/.cowstate.xml"));

         VFSUtil.touch(root.resolveFile("corrupted/nested-state/.cow/cow-links/.cowstate.xml"));

         VFSUtil.touch(root.resolveFile("corrupted/not-a-folder/.cow/deleted"));

         VFSUtil.touch(root.resolveFile("corrupted/not-a-folder/.cow/link"));

         VFSUtil.touch(root.resolveFile("corrupted/not-a-folder/.cow/cow-links"));

         VFSUtil.touch(root.resolveFile("corrupted/nested-dir/.cow/unknown1/file"));

         VFSUtil.touch(root.resolveFile("corrupted/nested-dir/.cow/unknown2/file"));

         VFSUtil.touch(root.resolveFile("corrupted/blank-state/.cowstate.xml"));

         VFSUtil.touch(root.resolveFile("corrupted/blank-both/.cowstate.xml"));

         VFSUtil.touch(root.resolveFile("corrupted/blank-both/.cow/deleted/file1"));

         VFSUtil.touch(root.resolveFile("corrupted/both/.cow/deleted/file1"));

         VFSUtil.setString(root, "corrupted/both/.cowstate.xml", "<state><item name=\"file1\" deleted=\"true\"/></state>\n");

         OutputStream out = root.resolveFile("corrupted/bad-link-file/.cow/link/bad-utf8").getContent().getOutputStream();

         out.write(0xc2);

         out.close();

         VFSUtil.setString(root, "corrupted/empty/.cowstate.xml", "<state/>\n");

         VFSUtil.touch(root.resolveFile("convert/.cow/deleted/deleted-file"));

         VFSUtil.setString(root, "convert/.cow/link/linked-file", "target");

         VFSUtil.setString(root, "convert/.cow/cow-links/overlay", "base-1\nbase-2\nbase-3\n");

         fsck.run();

     }

 }