Application: gvSIG desktop

package org.gvsig.fmap.dal.explorer.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.DataExplorerParameters;

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.InitializeException;

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.extensionpoint.ExtensionBuilder;

public class FilesystemExplorer implements DataExplorerProvider {

        // 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;

        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 ((FilterWraper) this.it.next()).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 void init(DataExplorerParameters parameters)

                        throws InitializeException {

                this.parameters = (FilesystemExplorerParameters) parameters;

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

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

        }

        public String getType() {

                return NAME;

        }

        public DataExplorerParameters 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) {

                // FIXME Comprobar si es un directorio existente

                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) {

                // TODO Auto-generated method stub

                return null;

        }

        public boolean canAdd(String storeName)

                        throws DataException {

                //                String providerName = parameters.getDataStoreName();

                //                this.checkIsMine(parameters);

                //

                //                DataStoreProvider provider = this.getManager().createStoreProvider(

                //                                providerName);

                //

                //                return provider.canCreate(parameters);

                return false;

        }

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

        private DataManagerProviderServices getManager() {

                return (DataManagerProviderServices) DALLocator.getDataManager();

        }

        private 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 = DALLocator.getDataManager()

                                                .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 (!file.getAbsolutePath().startsWith(this.root.getAbsolutePath())) {

                        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");

        }

}