package refactorapp;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import refactorapp.counters.*;

public class FileScaner {

    private CountResults resultCount;
    private LineReader lineReader;
    private String pattern;
    private File file;

    public void scan(String baseDir, String pattern) {


        this.pattern = pattern;
        File[] dirStack = new File[100];
        int dirStackPtr = 0;

        resultCount = new CountResults();
        lineReader = new LineReader();

        File dir = new File(baseDir);
        while (dir != null) {
            System.out.println("Scanning " + dir);
            File[] fileList = dir.listFiles();
            for (int i = 0; i < fileList.length; i++) {
                file = fileList[i];
                System.out.println("Processing " + file);
                if (file.isDirectory()) {
                    dirStack[dirStackPtr++] = file;
                    continue;
                }

                if (file.isFile()) {
                    i = 0;
                    processFile(file, pattern);
                }
            }
            dir = null;
            if (dirStackPtr > 0) {
                dir = dirStack[--dirStackPtr];
            }
        }
        getResultCount().print();
    }

    private void processFile(File file, String pattern) {

        String fileExtension = getFileExtension(file);
        getResultCount().incrementFileCount();
        try {
            if (fileExtension.equals(".java")) {
                processJavaFile(pattern, file);
            } else if (fileExtension.equals(".sh")) {
                processShFile(pattern, file);
            } else {
                processAnyFile(pattern, file);
            }
        } catch (IOException ex) {
            System.out.println("IOException on file " + file.getAbsolutePath() + file.getName());
        }
    }

    private String getFileExtension(File file) {
        if (file.getName().contains(".")) {
            return file.getName().substring(file.getName().lastIndexOf("."));
        }
        return "";

    }

    class BaseLineProcessor implements LineProcessor {

        protected CounterChain counterChain;
        protected List<Counter> counterList = new ArrayList<Counter>();

        void add(Counter counter) {
            counterList.add(counter);
        }

        @Override
        public void processLine(String line) {
            throw new UnsupportedOperationException("Not supported yet.");
        }

        class ShFileProcessor extends BaseLineProcessor {

            @Override
            public void processLine(String line) {
                counterChain.processLine(line, resultCount);
            }

            ShFileProcessor() {

                add(new LineCounter());
                add(new ShRemarkCounter());
                add(new PatternMatchesCounter(pattern, file));
                add(new WordCounter());
                add(new CharacterCounter());
                add(new NonEmptyLinesCounter());
                counterChain = new CounterChain(counterList);
            }
        }

        public LineProcessor returnShFileProcessor() {
            return new ShFileProcessor();
        }

        class JavaFileProcessor extends BaseLineProcessor {

            @Override
            public void processLine(String line) {
                counterChain.processLine(line, resultCount);
            }

            JavaFileProcessor() {

                add(new LineCounter());
                add(new JavaRemarkCounter());
                add(new PatternMatchesCounter(pattern, file));
                add(new JavaWordsCounter());
                add(new CharacterCounter());
                add(new NonEmptyLinesCounter());
                counterChain = new CounterChain(counterList);
            }
        }

        public LineProcessor returnJavaFileProcessor() {
            return new JavaFileProcessor();
        }

        public class AnyFileProcessor extends BaseLineProcessor {

            @Override
            public void processLine(String line) {
                counterChain.processLine(line, resultCount);
            }

            AnyFileProcessor() {

                add(new LineCounter());
                add(new PatternMatchesCounter(pattern, file));
                add(new WordCounter());
                add(new CharacterCounter());
                add(new NonEmptyLinesCounter());
                counterChain = new CounterChain(counterList);
            }
        }

        public LineProcessor returnAnyFileProcessor() {
            return new AnyFileProcessor();
        }
    }

    private void processAnyFile(String pattern, File file) throws IOException {
        BaseLineProcessor lineProcessor = new BaseLineProcessor();
        lineReader.readLine(file, lineProcessor.returnAnyFileProcessor());
    }

    private void processShFile(String pattern, File file) throws IOException {
        BaseLineProcessor lineProcessor = new BaseLineProcessor();
        lineReader.readLine(file, lineProcessor.returnShFileProcessor());
    }

    private void processJavaFile(String pattern, File file) throws IOException {
        BaseLineProcessor lineProcessor = new BaseLineProcessor();
        lineReader.readLine(file, lineProcessor.returnJavaFileProcessor());
    }

    public static void main(String[] args) {
    }

    /**
     * @return the resultCount
     */
    public CountResults getResultCount() {
        return resultCount;
    }

    /**
     * @return the pattern
     */
    public String getPattern() {
        return pattern;
    }

    /**
     * @return the file
     */
    public File getFile() {
        return file;
    }
}