Application: gvSIG desktop

package org.gvsig.fmap.dal.serverexplorer.filesystem;

import java.io.File;

import java.io.FileFilter;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.FileNotFoundException;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException;

import org.gvsig.fmap.dal.exception.RemoveException;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.spi.DataServerExplorerProvider;

import org.gvsig.fmap.dal.spi.DataServerExplorerProviderServices;

import org.gvsig.fmap.dal.spi.DataStoreProvider;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.extensionpoint.ExtensionBuilder;

import org.gvsig.tools.extensionpoint.ExtensionPoint.Extension;

public class FilesystemExplorer implements DataServerExplorerProvider {

        // FIXME: , IPersistence{

        public static final String NAME = "FilesystemExplorer";

        final private static String FILE_FILTER_EPSNAME = "FilesystemExplorerFilters";

        final private static String FILE_FILTER_EPSDESCRIPTION = "Registro de filtros asociados al explorador del sistema de ficheros.";

        FilesystemExplorerParameters parameters;

        private File root;

        private File current;

        private DataServerExplorerProviderServices providerServices;

        public static class FilterWraper implements ExtensionBuilder {

                private FileFilter filter;

                public FilterWraper(FileFilter filter) {

                        this.filter = filter;

                }

                public Object create() {

                        return filter;

                }

                public Object create(Object[] args) {

                        return filter;

                }

                public Object create(Map args) {

                        return filter;

                }

        }

        public static class FilterWraperIterator implements Iterator {

                private Iterator it;

                public FilterWraperIterator(Iterator it) {

                        this.it = it;

                }

                public boolean hasNext() {

                        return this.it.hasNext();

                }

                public Object next() {

                        return ((Extension) this.it.next()).getBuilder().create();

                }

                public void remove() {

                        throw new UnsupportedOperationException();

                }

        }

        public static void registerFilter(FilesystemFileFilter filter) {

                FilterWraper filterWraper = new FilterWraper(filter);

                ToolsLocator.getExtensionPointManager().add(FILE_FILTER_EPSNAME,

                                FILE_FILTER_EPSDESCRIPTION).append(

                                filter.getDataStoreProviderName(), filter.getDescription(),

                                filterWraper);

        }

        public static Iterator getFilters() {

                Iterator it = new FilterWraperIterator(ToolsLocator

                                .getExtensionPointManager().get(FILE_FILTER_EPSNAME).iterator());

                return it;

        }

        public FilesystemExplorer(FilesystemExplorerParameters parameters)

                        throws InitializeException {

                this.parameters = parameters;

                this.root = new File(this.parameters.getRoot());

                if (this.parameters.getInitialpath() == null) {

                        this.current = new File(this.parameters.getRoot());

                }else{

                        this.current = new File(this.parameters.getInitialpath());

                }

        }

        public String getType() {

                return NAME;

        }

        public DataServerExplorerParameters getParameters() {

                return parameters;

        }

        public void dispose() throws DataException {

                this.parameters = null;

                this.root = null;

        }

        public List list() throws DataException {

                if (!this.current.exists()) {

                        //TODO crear excepcion de Data??

                        new org.gvsig.fmap.dal.exception.FileNotFoundException(this.current);

                }

                if (!this.current.isDirectory()) {

                        new IllegalArgumentException(this.getName()

                                        + ": Path not a directory '"

                                        + this.current + "'");

                }

                // DataManager dsm=DataManager.getManager();

                String files[] = this.current.list();

                int i;

                File theFile;

                ArrayList list = new ArrayList();

                DataStoreParameters dsp = null;

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

                        theFile = new File(this.root, files[i]);

                        dsp = this.getParametersFor(theFile);

                        if (dsp != null) {

                                list.add(dsp);

                        }

                }

                return list;

        }

        public void setCurrentPath(File path) throws FileNotFoundException {

                // FIXME Comprobar si es un directorio existente

                if (!path.exists()) {

                        throw new FileNotFoundException(path);

                }

                if (!path.isDirectory()) {

                        throw new IllegalArgumentException(path.getPath()

                                        + " is not a directory");

                }

                if (!isFromRoot(path)) {

                        throw new IllegalArgumentException(path.getPath()

                                        + " is not from root");

                }

                this.current = path;

        }

        public File getCurrentPath() {

                return this.current;

        }

        public File getRoot() {

                return this.root;

        }

        public void remove(DataStoreParameters dsp) throws RemoveException {

                String providerName = dsp.getDataStoreName();

                try {

                        this.checkIsMine(dsp);

                        DataStoreProvider provider = this.getManager().createStoreProvider(

                                        providerName);

                        provider.remove(dsp);

                } catch (DataException e) {

                        throw new RemoveException(this.getName(), e);

                }

        }

        public boolean add(NewDataStoreParameters ndsp, boolean overwrite)

                        throws DataException {

                String providerName = ndsp.getDataStoreName();

                this.checkIsMine(ndsp);

                try {

                        DataStoreProvider provider = this.getManager().createStoreProvider(

                                        providerName);

                        provider.create(ndsp, overwrite);

                        return true; // TODO deber?a devolver un booleano el provider o esto ser un void

                } catch (DataException e) {

                        throw new RemoveException(this.getName(), e);

                }

        }

        public boolean canAdd() {

                return this.root.canWrite();

        }

        public String getName() {

                return this.FILE_FILTER_EPSNAME;

        }

        public NewDataStoreParameters getAddParameters(String storeName)

                        throws DataException {

                DataStoreProvider provider = this.getProvider(storeName);

                if (provider == null) {

                        throw new IllegalArgumentException(

                                        "Not registered in this explorer"); // FIXME

                }

                NewDataStoreParameters nParams = provider.getCreateParameters();

                //                nParams.setAttribute("path", this.getCurrentPath().getPath());

                return nParams;

        }

        public boolean canAdd(String storeName)

                        throws DataException {

                DataStoreProvider provider = this.getProvider(storeName);

                if (provider == null) {

                        throw new IllegalArgumentException(

                                        "Not registered in this explorer"); // FIXME

                }

                return provider.canCreate();

        }

        // ==========================================

        private DataStoreProvider getProvider(String storeName)

                        throws InitializeException, ProviderNotRegisteredException {

                Iterator filters = getFilters();

                while (filters.hasNext()) {

                        FilesystemFileFilter filter = (FilesystemFileFilter) filters.next();

                        if (filter.getDataStoreProviderName().equals(storeName)) {

                                return this.getManager().createStoreProvider(storeName);

                        }

                }

                return null;

        }

        private DataManagerProviderServices getManager() {

                return (DataManagerProviderServices) DALLocator.getDataManager();

        }

        public DataStoreParameters getParametersFor(File file)

                        throws DataException {

                if (!file.exists()) {

                        return null;

                }

                if (!file.isFile()) {

                        return null;

                }

                if (!file.canRead()) {

                        return null;

                }

                if (file.isHidden()) { // XXX ???

                        return null;

                }

                Iterator filters = getFilters();

                while (filters.hasNext()) {

                        FilesystemFileFilter filter = (FilesystemFileFilter) filters.next();

                        if (filter.accept(file)) {

                                DataStoreParameters params = this.getManager()

                                                .createStoreParameters(

                                                                filter.getDataStoreProviderName());

                                ((FilesystemStoreParameters) params).setFile(file);

                                return params;

                        }

                }

                return null;

        }

        private void checkIsMine(DataStoreParameters dsp)

                        throws IllegalArgumentException, DataException {

                if (!(dsp instanceof FilesystemExplorer)) {

                        new IllegalArgumentException("not instance of FilesystemExplorer");

                }

                Iterator filters = getFilters();

                File file = ((FilesystemStoreParameters) dsp).getFile();

                if (!this.isFromRoot(file)) {

                        throw new IllegalArgumentException("worng explorer");

                }

                FilesystemFileFilter filter;

                while (filters.hasNext()) {

                        filter = (FilesystemFileFilter) filters.next();

                        if (dsp.getDataStoreName().equals(filter.getDataStoreProviderName())) {

                                return;

                        }

                }

                throw new IllegalArgumentException("worng explorer");

        }

        private boolean isFromRoot(File file) {

                return file.getAbsolutePath().startsWith(this.root.getAbsolutePath());

        }

        public void initialize(

                        DataServerExplorerProviderServices dataServerExplorerProviderServices) {

                this.providerServices = dataServerExplorerProviderServices;

        }

}