/**********************************import java.io.File;
import java.io.IOException;

import blanco.properties.BlancoPropertiesUtil;
import blanco.xliff.BlancoXliffUtil;
import blanco.xliff.stringgroup.BlancoXliffStateStringGroup;
import blanco.xliff.util.task.valueobject.BlancoXliffUtilExtractNeedsTranslationProcessInput;
import blanco.xliff.valueobject.BlancoXliff;
import blanco.xliff.valueobject.BlancoXliffFile;
import blanco.xliff.valueobject.BlancoXliffTransUnit;
I and implementation
 *******************************************************************************/
/*
 * blanco Framework
 * Copyright (C) 2008 NTT DATA BUSINESS BRAINS CORPORATION
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 */
package blanco.xliff.util.task;

import java.io.File;
import java.io.IOException;

import blanco.properties.BlancoPropertiesUtil;
import blanco.xliff.BlancoXliffUtil;
import blanco.xliff.stringgroup.BlancoXliffStateStringGroup;
import blanco.xliff.util.task.valueobject.BlancoXliffUtilExtractNeedsTranslationProcessInput;
import blanco.xliff.valueobject.BlancoXliff;
import blanco.xliff.valueobject.BlancoXliffFile;
import blanco.xliff.valueobject.BlancoXliffTransUnit;

public class BlancoXliffUtilExtractNeedsTranslationProcessImpl implements
        BlancoXliffUtilExtractNeedsTranslationProcess {
    private BlancoXliffUtilExtractNeedsTranslationProcessInput fInput = null;

    private BlancoXliff fXliffTarget = new BlancoXliff();

    public int execute(
            final BlancoXliffUtilExtractNeedsTranslationProcessInput input)
            throws IOException, IllegalArgumentException {
        fInput = input;

        final File fileXliffdir = new File(input.getXliffdir());
        final File[] files = fileXliffdir.listFiles();
        if (files == null) {
            return 0;
        }
        for (int index = 0; index < files.length; index++) {
            if (files[index].isFile() == false) {
                continue;
            }
            if (files[index].getName().endsWith(".xlf")) {
                process(fileXliffdir, files[index]);
            }
        }

        final File fileTargetfile = new File(fInput.getTargetfile());
        if (fileTargetfile.getParentFile().exists() == false) {
            fileTargetfile.getParentFile().mkdirs();
        }
        BlancoXliffUtil.saveXliffInstance(fXliffTarget, new File(fileTargetfile
                .getParentFile().getAbsolutePath()), fileTargetfile.getName()
                .substring(0,
                        fileTargetfile.getName().length() - ".xlf".length()));

        return 0;
    }

    private void process(final File fileXliffdir, final File fileTarget)
            throws IOException {

        final String bundleSymbolicName = fileTarget.getName().substring(0,
                fileTarget.getName().length() - ".xlf".length());

        final BlancoXliff fXliff = BlancoXliffUtil.getXliffInstance(
                fileXliffdir, bundleSymbolicName);

        for (int indexFile = 0; indexFile < fXliff.getFileList().size(); indexFile++) {
            final BlancoXliffFile file = fXliff.getFileList().get(indexFile);
            processFile(file);
        }
    }

    private void processFile(final BlancoXliffFile file) {
        for (int index = 0; index < file.getBody().getTransUnitList().size(); index++) {
            final BlancoXliffTransUnit transUnit = file.getBody()
                    .getTransUnitList().get(index);

            if (transUnit.getTranslate() == false) {
                // 除外項目。
                continue;
            }

            if (BlancoPropertiesUtil.isPreferenceKeywords(transUnit.getId())) {
                if (fInput.getVerbose()) {
                    System.out.println("uri[" + transUnit.getId()
                            + "] はプリファランス・キーワードであるため翻訳対象から除外します。");
                }
                continue;
            }

            if (transUnit.getTarget() == null) {
                if (fInput.getGettargetnotexist()) {
                    // 処理対象
                    processTransUnit(transUnit);
                }
            } else {
                switch (new BlancoXliffStateStringGroup()
                        .convertToInt(transUnit.getTarget().getState())) {
                case BlancoXliffStateStringGroup.NEW:
                    if (fInput.getGetstatenew()) {
                        // 処理対象
                        processTransUnit(transUnit);
                    }
                    break;
                case BlancoXliffStateStringGroup.NEEDS_TRANSLATION:
                    if (fInput.getGetstateneedstranslation()) {
                        // 処理対象
                        processTransUnit(transUnit);
                    }
                    break;
                default:
                    // 処理対象外
                    break;
                }
            }
        }
    }

    private void processTransUnit(final BlancoXliffTransUnit transUnit) {
        if (fXliffTarget.getFileList().size() == 0) {
            final BlancoXliffFile xliffFile = new BlancoXliffFile();
            fXliffTarget.getFileList().add(xliffFile);
        }

        final BlancoXliffFile xliffFile = fXliffTarget.getFileList().get(0);

        // 同じ source 文字列の他の登録がないかどうかチェックします。
        for (int indexExist = 0; indexExist < xliffFile.getBody()
                .getTransUnitList().size(); indexExist++) {
            final BlancoXliffTransUnit registered = xliffFile.getBody()
                    .getTransUnitList().get(indexExist);
            if (registered.getSource().equals(transUnit.getSource())) {
                // 既に登録あり。
                // 何もせずに処理スキップします。
                // ※Note転送のような処理は このケースでは不要です。
                return;
            }
        }

        xliffFile.getBody().getTransUnitList().add(transUnit);
    }
}
