package jalview.fts.core;

import jalview.fts.api.FTSDataColumnGroupI;
import jalview.fts.api.FTSDataColumnI;
import jalview.fts.api.FTSRestClientI;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Objects;

public abstract class FTSRestClient implements FTSRestClientI
{
  protected Collection<FTSDataColumnI> dataColumns = new ArrayList<FTSDataColumnI>();

  protected Collection<FTSDataColumnGroupI> dataColumnGroups = new ArrayList<FTSDataColumnGroupI>();

  protected Collection<FTSDataColumnI> searchableDataColumns = new ArrayList<FTSDataColumnI>();

  protected Collection<FTSDataColumnI> defaulDisplayedDataColumns = new ArrayList<FTSDataColumnI>();

  protected FTSDataColumnI primaryKeyColumn;

  protected FTSRestClient()
  {

  }

  public void parseDataColumnsFile()
  {
    String fileName = getColumnDataConfigFile();
    try (BufferedReader br = new BufferedReader(new FileReader(fileName)))
    {
      String line;
      while ((line = br.readLine()) != null)
      {
        final String[] lineData = line.split(";");
        if (lineData.length == 3)
        {
          dataColumnGroups.add(new FTSDataColumnGroupI()
          {
            @Override
            public String getID()
            {
              return lineData[0];
            }

            @Override
            public String getName()
            {
              return lineData[1];
            }

            @Override
            public int getSortOrder()
            {
              return Integer.valueOf(lineData[2]);
            }

            @Override
            public String toString()
            {
              return lineData[1];
            }

            @Override
            public int hashCode()
            {
              return Objects.hash(this.getID(), this.getName(),
                      this.getSortOrder());
            }

            @Override
            public boolean equals(Object otherObject)
            {
              FTSDataColumnGroupI that = (FTSDataColumnGroupI) otherObject;
              return this.getID().equals(that.getID())
                      && this.getName().equals(that.getName())
                      && this.getSortOrder() == that.getSortOrder();
            }
          });
        }
        else if (lineData.length > 6)
        {
          FTSDataColumnI dataCol = new FTSDataColumnI()
          {
            @Override
            public String toString()
            {
              return lineData[0];
            }

            @Override
            public String getName()
            {
              return lineData[0];
            }

            @Override
            public String getCode()
            {
              return lineData[1];
            }

            @Override
            public FTSDataColumnGroupI getGroup()
            {
              FTSDataColumnGroupI group = null;
              try
              {
                group = getDataColumnGroupById(lineData[2]);
              } catch (Exception e)
              {
                e.printStackTrace();
              }
              return group;
            }

            @Override
            public int getMinWidth()
            {
              return Integer.valueOf(lineData[3]);
            }

            @Override
            public int getMaxWidth()
            {
              return Integer.valueOf(lineData[4]);
            }

            @Override
            public int getPreferredWidth()
            {
              return Integer.valueOf(lineData[5]);
            }


            @Override
            public boolean isPrimaryKeyColumn()
            {
              return Boolean.valueOf(lineData[6]);
            }

            @Override
            public boolean isVisibleByDefault()
            {
              return Boolean.valueOf(lineData[7]);
            }

            @Override
            public boolean isSearchable()
            {
              return Boolean.valueOf(lineData[8]);
            }

            @Override
            public int hashCode()
            {
              return Objects.hash(this.getName(), this.getCode(),
                      this.getGroup());
            }

            @Override
            public boolean equals(Object otherObject)
            {
              FTSDataColumnI that = (FTSDataColumnI) otherObject;
              return this.getCode().equals(that.getCode())
                      && this.getName().equals(that.getName())
                      && this.getGroup().equals(that.getGroup());
            }
          };
          dataColumns.add(dataCol);

          if (dataCol.isSearchable())
          {
            searchableDataColumns.add(dataCol);
          }

          if (dataCol.isVisibleByDefault())
          {
            defaulDisplayedDataColumns.add(dataCol);
          }

        }
        else
        {
          continue;
        }
      }
    } catch (IOException e)
    {
      e.printStackTrace();
    }
  }

  /**
   * Determines the column index for 'Primary key' Fields in the dynamic summary
   * table.
   * 
   * @param wantedFields
   *          the available table columns in no particular order
   * @return the primary key column index
   * @throws Exception
   */
  @Override
  public int getPrimaryKeyColumIndex(
          Collection<FTSDataColumnI> wantedFields,
          boolean hasRefSeq) throws Exception
  {

    // If a reference sequence is attached then start counting from 1 else
    // start from zero
    int pdbFieldIndexCounter = hasRefSeq ? 1 : 0;

    for (FTSDataColumnI field : wantedFields)
    {
      if (field.isPrimaryKeyColumn())
      {
        break; // Once PDB Id index is determined exit iteration
      }
      ++pdbFieldIndexCounter;
    }
    return pdbFieldIndexCounter;
  }

  /**
   * Takes a collection of FTSDataColumnI and converts its 'code' values into a
   * comma delimited string.
   * 
   * @param dataColumnFields
   *          the collection of FTSDataColumnI to process
   * @return the generated comma delimited string from the supplied
   *         FTSDataColumnI collection
   */
  public static String getDataColumnsFieldsAsCommaDelimitedString(
          Collection<FTSDataColumnI> dataColumnFields)
  {
    String result = "";
    if (dataColumnFields != null && !dataColumnFields.isEmpty())
    {
      StringBuilder returnedFields = new StringBuilder();
      for (FTSDataColumnI field : dataColumnFields)
      {
        returnedFields.append(",").append(field.getCode());
      }
      returnedFields.deleteCharAt(0);
      result = returnedFields.toString();
    }
    return result;
  }

  @Override
  public Collection<FTSDataColumnI> getAllFTSDataColumns()
  {
    if (dataColumns == null || dataColumns.isEmpty())
    {
      parseDataColumnsFile();
    }
    return dataColumns;
  }

  @Override
  public Collection<FTSDataColumnI> getSearchableDataColumns()
  {
    if (searchableDataColumns == null || searchableDataColumns.isEmpty())
    {
      parseDataColumnsFile();
    }
    return searchableDataColumns;
  }

  @Override
  public Collection<FTSDataColumnI> getAllDefaulDisplayedDataColumns()
  {
    if (defaulDisplayedDataColumns == null
            || defaulDisplayedDataColumns.isEmpty())
    {
      parseDataColumnsFile();
    }
    return defaulDisplayedDataColumns;
  }

  @Override
  public FTSDataColumnI getPrimaryKeyColumn()
  {
    return primaryKeyColumn;
  }

  @Override
  public FTSDataColumnI getDataColumnByNameOrCode(
          String nameOrCode) throws Exception
  {
    for (FTSDataColumnI column : dataColumns)
    {
      if (column.getName().equalsIgnoreCase(nameOrCode)
              || column.getCode().equalsIgnoreCase(nameOrCode))
      {
        return column;
      }
    }
    throw new Exception("Couldn't find data column with name : "
            + nameOrCode);
  }

  @Override
  public FTSDataColumnGroupI getDataColumnGroupById(String id)
          throws Exception
  {
    for (FTSDataColumnGroupI columnGroup : dataColumnGroups)
    {
      if (columnGroup.getID().equalsIgnoreCase(id))
      {
        return columnGroup;
      }
    }
    throw new Exception("Couldn't find data column group with id : " + id);
  }

  protected String getFile(String fileName)
  {
    ClassLoader classLoader = getClass().getClassLoader();
    // File file = new File(classLoader.getResource(fileName).getFile());
    String result = "";
    try
    {
      result = classLoader.getResource(fileName).getFile();
    } catch (Exception e)
    {
      e.printStackTrace();
    }
    return result;

  }

}