package br.mia.test.util;

 import java.awt.Toolkit;

 import java.awt.datatransfer.Clipboard;

 import java.awt.datatransfer.DataFlavor;

 import java.awt.datatransfer.Transferable;

 import java.awt.datatransfer.UnsupportedFlavorException;

 import java.io.BufferedReader;

 import java.io.File;

 import java.io.FileInputStream;

 import java.io.FileReader;

 import java.io.IOException;

 import java.sql.SQLException;

 import java.util.ArrayList;

 import java.util.Iterator;

 import java.util.LinkedHashMap;

 import java.util.List;

 import java.util.Properties;

 import javax.swing.JComboBox;

 import javax.swing.JFileChooser;

 import javax.swing.JTable;

 import org.apache.log4j.Logger;

 import br.mia.test.model.CasoUso;

 import br.mia.test.model.Filtro;

 import br.mia.test.model.Fluxo;

 import br.mia.test.model.Link;

 import br.mia.test.model.RegraNegocio;

 import br.mia.test.model.RegraNegocioStep;

 import br.mia.test.model.Step;

 import br.mia.test.model.TestDataValor;

 import br.mia.test.model.algoritmo.Algoritmo;

 import br.mia.test.model.dao.DAOBussinessRule;

 import br.mia.test.testcase.CasosTeste;

 import br.mia.test.testcase.DadosTeste;

 import br.mia.test.view.Global;

 public class Util

 {

     public static Algoritmo retornaAlgoritmoCasosTeste(CasoUso useCase)

             throws InstantiationException, IllegalAccessException,

             ClassNotFoundException, SQLException, IOException {

         Algoritmo alg = new Algoritmo();

         alg.limpaArvore(useCase);

         alg.retornaCenarios((Fluxo) useCase.getFlows().get(0), 0,

                 new CasosTeste(), 0, useCase);

         ArrayList<CasosTeste> casosTeste = alg.getCasosDeTeste();

         for (Object object : casosTeste) {

             CasosTeste casoTeste = (CasosTeste) object;

             alg.applyData(casoTeste, 0, new CasosTeste(), useCase, true);

         }

         return alg;

     }

     public static Logger getLogger() {

         return Logger.getLogger("testkase");

     }

     public static String getTestCaseName(CasoUso useCase, int id,

             CasosTeste testCase) throws IOException {

         String regra = Util.getPropriedade("testcasename");

         String nome;

         if (regra != null) {

             if (regra.contains("FN")) {

                 StringBuffer nomeFluxo = new StringBuffer();

                 for (Fluxo flow : testCase.getFlows()) {

                     String nomeReduzido = flow.getName().substring(0, 2);

                     if (!(nomeFluxo.toString().contains(nomeReduzido))) {

                         nomeFluxo.append(nomeReduzido);

                     }

                 }

                 nome = useCase.getName() + nomeFluxo.toString() + "-CT";

             } else {

                 nome = useCase.getName() + "-CT" + id;

             }

             if (regra.contains("DT")) {

                 nome += (new java.util.Date()).toString();

             }

         } else {

             nome = useCase.getName() + "-CT" + id;

         }

         return nome;

     }

     public static File[] getFiles() {

         JFileChooser fc = new JFileChooser();

         fc.setMultiSelectionEnabled(true);

         fc.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);

         int returnVal = fc.showOpenDialog(Global.getMidpane());

         if (returnVal == JFileChooser.APPROVE_OPTION) {

             return fc.getSelectedFiles();

         } else {

             return null;

         }

     }

     public static String readFile(File file) throws IOException {

         BufferedReader in = new BufferedReader(new FileReader(file));

         StringBuffer sb = new StringBuffer();

         String line = "";

         while ((line = in.readLine()) != null) {

             sb.append(line);

         }

         return sb.toString();

     }

     public static ArrayList<String> readFileArray(File file) throws IOException {

         BufferedReader in = new BufferedReader(new FileReader(file));

         ArrayList<String> sb = new ArrayList<String>();

         String line = "";

         while ((line = in.readLine()) != null) {

             sb.add(line);

         }

         return sb;

     }

     public static ArrayList<TestDataValor> getValores(File file)

             throws IOException {

         ArrayList<TestDataValor> array = new ArrayList<TestDataValor>();

         ArrayList<String> valoresString = readFileArray(file);

         for (String linha : valoresString) {

             String termos[] = linha.split(",");

             TestDataValor valor = new TestDataValor();

             valor.setValor(termos[0]);

             valor.setResultadoEsperado(termos[1]);

             valor.setClasse(termos[2]);

             array.add(valor);

         }

         return array;

     }

     public static String getPropriedade(String propriedade) throws IOException {

         File file = new java.io.File("config.properties");

         FileInputStream iof = new FileInputStream(file);

         Properties properties = new Properties();

         properties.load(iof);

         return properties.getProperty(propriedade);

     }

     public JComboBox comboDados(CasoUso useCase) {

         return new JComboBox(Util.getDataUseCase(useCase).toArray());

     }

     public void recarregaCombo(JComboBox combo, Object[] array) {

         if (combo != null) {

             combo.removeAllItems();

             Object[] aux = (Object[]) array;

             for (Object objeto : aux) {

                 combo.addItem(objeto);

             }

         } else {

             combo = new JComboBox(array);

         }

         combo.setVisible(false);

         combo.revalidate();

         combo.setVisible(true);

         combo.repaint();

     }

     public static DadosTeste getDataTable(JTable datas, CasoUso useCase) {

         return (DadosTeste) getDataUseCase(useCase).get(datas.getSelectedRow());

     }

     public static void zeraIdArrayValores(List<TestDataValor> valores1) {

         for (Iterator<TestDataValor> iterator = valores1.iterator(); iterator

                 .hasNext();) {

             TestDataValor type = (TestDataValor) iterator.next();

             type.setId(0);

         }

     }

     public static void zeraIdUseCase(CasoUso useCase) {

         useCase.setId(0);

         List<Fluxo> flows = useCase.getFlows();

         ArrayList<DadosTeste> datas = Util.getDataUseCase(useCase);

         List<RegraNegocio> regras = useCase.getRegras();

         for (Iterator<Fluxo> iterator = flows.iterator(); iterator.hasNext();) {

             Fluxo flow = (Fluxo) iterator.next();

             flow.setIdFlow(0);

             List<Step> steps = flow.getSteps();

             for (Iterator<Step> iterator1 = steps.iterator(); iterator1

                     .hasNext();) {

                 Step step = (Step) iterator1.next();

                 step.setId(0);

                 ArrayList<Link> links = (ArrayList<Link>) step.getLinks();

                 for (Iterator<Link> iterator4 = links.iterator(); iterator4

                         .hasNext();) {

                     Link link = (Link) iterator4.next();

                     link.setId(0);

                 }

                 for (Filtro filtro : step.getFiltros()) {

                     filtro.setId(0);

                 }

                 ArrayList<DadosTeste> testDatas = (ArrayList<DadosTeste>) step

                         .getDatas();

                 for (Iterator<DadosTeste> iterator5 = testDatas.iterator(); iterator5

                         .hasNext();) {

                     DadosTeste data = (DadosTeste) iterator5.next();

                     data.setId(0);

                 }

             }

         }

         for (Iterator<DadosTeste> iterator2 = datas.iterator(); iterator2

                 .hasNext();) {

             DadosTeste data = (DadosTeste) iterator2.next();

             data.setId(0);

             List<TestDataValor> valores = data.getValues();

             for (Iterator<TestDataValor> iterator3 = valores.iterator(); iterator3

                     .hasNext();) {

                 TestDataValor valor = (TestDataValor) iterator3.next();

                 valor.setId(0);

             }

         }

         if (regras != null) {

             for (RegraNegocio regraNegocio : regras) {

                 regraNegocio.setId(0);

                 for (RegraNegocioStep step : regraNegocio.getSteps()) {

                     step.setId(0);

                 }

             }

         }

     }

     public static void zeraIdArraySteps(ArrayList<Step> valores) {

         for (Iterator<Step> iterator = valores.iterator(); iterator.hasNext();) {

             Step type = (Step) iterator.next();

             type.setId(0);

         }

     }

     public static String getClipboardContents()

             throws UnsupportedFlavorException, IOException {

         String result = "";

         Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();

         Transferable contents = clipboard.getContents(null);

         boolean hasTransferableText = (contents != null)

                 && contents.isDataFlavorSupported(DataFlavor.stringFlavor);

         if (hasTransferableText) {

             result = (String) contents.getTransferData(DataFlavor.stringFlavor);

         }

         return result;

     }

     public static DadosTeste getDataCombo(JComboBox combo, CasoUso useCase) {

         return (DadosTeste) getDataUseCase(useCase).get(

                 combo.getSelectedIndex());

     }

     public static TestDataValor getDataValor(JTable datas, JTable valores,

             CasoUso useCase) {

         return getDataTable(datas, useCase).getValues().get(

                 valores.getSelectedRow());

     }

     public static TestDataValor getDataValor(JTable datas, int index,

             CasoUso useCase) {

         return getDataTable(datas, useCase).getValues().get(index);

     }

     public static void putData(DadosTeste data, CasoUso useCase) {

         putData(useCase, data);

     }

     public static void putData(CasoUso useCase, DadosTeste data) {

         useCase.getDataMapaGlobal().put(

                 data.getName() + useCase.getName() + useCase.getId(), data);

     }

     public static void removeData(DadosTeste data, CasoUso useCase) {

         removeData(useCase, data);

     }

     public static void removeData(CasoUso useCase, DadosTeste data) {

         useCase.getDataMapaGlobal().remove(

                 data.getName() + useCase.getName() + useCase.getId());

     }

     public static DadosTeste getData(int index, CasoUso useCase) {

         return (DadosTeste) getDataUseCase(useCase).get(index);

     }

     public static ArrayList<DadosTeste> getDataUseCase(CasoUso useCase) {

         return new ArrayList<DadosTeste>(useCase.getDataMapaGlobal().values());

     }

     public static RegraNegocio getBussinessRule(int id, CasoUso useCase) {

         List<RegraNegocio> array = useCase.getRegras();

         return (RegraNegocio) array.get(id);

     }

     @SuppressWarnings("unchecked")

     public static ArrayList<Object> toArray(LinkedHashMap mapa) {

         ArrayList<Object> array = new ArrayList<Object>(mapa.values());

         return array;

     }

     public static void recarga(CasoUso useCase) throws InstantiationException,

             IllegalAccessException, ClassNotFoundException, SQLException,

             IOException {

         DAOBussinessRule daoRule = new DAOBussinessRule();

         // CasoUso.setRegras(daoRule.selectBussinessRule(useCase));

     }

     public static void insereRegra(CasoUso useCase, RegraNegocio rule) {

         if (!(useCase.getRuleMapaGlobal().containsKey(rule.getName()

                 + useCase.getName()))) {

             useCase.getRuleMapaGlobal().put(rule.getName() + useCase.getName(),

                     rule);

         }

     }

     public static void zeraIdArrayRegraNegocioSteps(

             List<RegraNegocioStep> valores1) {

         for (Iterator<RegraNegocioStep> iterator = valores1.iterator(); iterator

                 .hasNext();) {

             RegraNegocioStep type = (RegraNegocioStep) iterator.next();

             type.setId(0);

         }

     }

 }