#ifndef STRING_LIB_H
#define STRING_LIB_H

#include <stdlib.h>
#include <strings.h>
#include <string.h>
#include <ctype.h>
#include <locale.h>

#include <lista_simples.h>

class String {
  
public:
  // Construtores: chamados quando se dá o 'new'
  String();
  /**
   *@param texto texto a ser colocado na string criada
   */
  String(const char *texto);
  /**
   *@param texto é a string a qual vai ter seu texto copiado para a nova string criada
   */
  String(const String &texto);
  /**
   *@param texto caracter a ser colocado na string criada
   */
  String(char texto);
  /**
   *@param texto número inteiro a ser convertido e colocado na string criada
   */
  String(int texto);
  /**
   *@param texto número inteiro a ser convertido e colocado na string criada
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  String(int texto, const char* formato);
  /**
   *@param texto número de dupla precisão a ser convertido e colocado na string criada
   */
  String(double texto);
  /**
   *@param texto número de dupla precisão a ser convertido e colocado na string criada
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  String(double texto, const char* formato);
  /**
   *@param texto número de ponto flutuante a ser convertido e colocado na string criada
   */
  String(float texto);
  /**
   *@param texto número de ponto flutuante  a ser convertido e colocado na string criada
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  String(float texto, const char* formato);
  /**
   *@param texto número inteiro longo a ser convertido e colocado na string criada
   */
  String(long texto);
  /**
   *@param texto número inteiro longo a ser convertido e colocado na string criada
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  String(long texto, const char* formato);

  // Destrutor: chamado quando se dá o 'delete'
  ~String();
  
  

  // Concatena: concatena ('junta') ao final desta string o 'texto'
  /**
   *@param texto será adicionado ao final desta string
   */
  void Concatena(const char* texto);
  /**
   *@param texto terá seu conteúdo(texto.Texto()) adicionado ao final desta string
   */
  void Concatena(String &texto);
  /**
   *@param texto é um caracter a ser adicionado ao final desta string
   */
  void Concatena(char texto);
  /**
   *@param texto é um número inteiro a ser adicionado ao final desta string
   */
  void Concatena(int texto);
  /**
   *@param texto é um número inteiro a ser adicionado ao final desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  void Concatena(int texto, const char* formato);
  /**
   *@param texto é um número de dupla precisão a ser adicionado ao final desta string
   */
  void Concatena(double texto);
  /**
   *@param texto é um número de dupla precisão a ser adicionado ao final desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  void Concatena(double texto, const char* formato);
  /**
   *@param texto é um número de ponto flutuante a ser adicionado ao final desta string
   */
  void Concatena(float texto);
  /**
   *@param texto é um número de ponto flutuante a ser adicionado ao final desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  void Concatena(float texto, const char* formato);
  /**
   *@param texto é um número inteiro longo a ser adicionado ao final desta string
   */
  void Concatena(long texto);
  /**
   *@param texto é um número inteiro longo a ser adicionado ao final desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  void Concatena(long texto, const char* formato);


  
  // PreConcatena: concatena ('junta') ao começo desta string o 'texto'
  /**
   *@param texto será adicionado ao início desta string
   */
  void PreConcatena(const char* texto);
  /**
   *@param texto terá seu conteúdo(texto.Texto()) adicionado ao início desta string
   */
  void PreConcatena(String &texto);
  /**
   *@param texto é um caracter a ser adicionado ao início desta string
   */
  void PreConcatena(char texto);
  /**
   *@param texto é um número inteiro a ser adicionado ao início desta string
   */
  void PreConcatena(int texto);
  /**
   *@param texto é um número inteiro a ser adicionado ao início desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  void PreConcatena(int texto, const char* formato);
  /**
   *@param texto é um número de dupla precisão a ser adicionado ao início desta string
   */
  void PreConcatena(double texto);
  /**
   *@param texto é um número de dupla precisão a ser adicionado ao início desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  void PreConcatena(double texto, const char* formato);
  /**
   *@param texto é um número de ponto flutuante a ser adicionado ao início desta string
   */
  void PreConcatena(float texto);
  /**
   *@param texto é um número de ponto flutuante a ser adicionado ao início desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  void PreConcatena(float texto, const char* formato);
  /**
   *@param texto é um número inteiro longo a ser adicionado ao início desta string
   */
  void PreConcatena(long texto);
  /**
   *@param texto é um número inteiro longo a ser adicionado ao início desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  void PreConcatena(long texto, const char* formato);
  


  // Muda_Texto: Muda o texto desta string para 'texto'
  /**
   *@param texto será o novo texto desta string
   */
  void Muda_Texto(const char* texto);
  /**
   *@param texto seu conteúdo(texto.Texto()) substituirá o desta string
   */
  void Muda_Texto(String texto);
  /**
   *@param texto é um caracter que será o novo texto desta string
   */
  void Muda_Texto(char texto);
  /**
   *@param texto é um número inteiro que será o novo texto desta string 
   */
  void Muda_Texto(int texto);
  /**
   *@param texto é um número inteiro que será o novo texto desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  void Muda_Texto(int texto, const char* formato);
  /**
   *@param texto é um número de dupla precisão que será o novo texto desta string
   */
  void Muda_Texto(double texto);
  /**
   *@param texto é um número de dupla precisão que será o novo texto desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  void Muda_Texto(double texto, const char* formato);
  /**
   *@param texto é um número de ponto flutuante que será o novo texto desta string
   */
  void Muda_Texto(float texto);
  /**
   *@param texto é um número de ponto flutuante que será o novo texto desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  void Muda_Texto(float texto, const char* formato);
  /**
   *@param texto é um número inteiro longo que será o novo texto desta string
   */
  void Muda_Texto(long texto);
  /**
   *@param texto é um número inteiro longo que será o novo texto desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   */
  void Muda_Texto(long texto, const char* formato);


  /**
   * Texto: retorna o texto desta string no formato 'char *'
   *@return texto desta string no formato 'char *'
   */
  char *Texto();

  /**
   * Para_Maiuscula: converte o texto da string atual para letras maiúsculas. 
   *OBS: Para converter corretamente as letras acentuadas, use antes a função String::Localizacao()
   */
  void Para_Maiuscula();

  /**
   * Para_Minuscula: converte o texto da string atual para letras minúsculas. 
   *OBS: Para converter corretamente as letras acentuadas, use antes a função String::Localizacao()
   */
  void Para_Minuscula();


  // Compara: Compara o texto desta string com 'texto'
  /**
   *@param texto a ser comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int Compara(const char* texto);
  /**
   *@param texto terá seu valor(texto.Texto()) comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int Compara(String &texto);
  /**
   *@param texto é um caractere a ser comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int Compara(char texto);
  /**
   *@param texto é um número inteiro a ser comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int Compara(int texto);
  /**
   *@param texto é um número inteiro a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int Compara(int texto, const char* formato);
  /**
   *@param texto é um número de dupla precisão a ser comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int Compara(double texto);
  /**
   *@param texto é um número de dupla precisão a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int Compara(double texto, const char* formato);
  /**
   *@param texto é um número de ponto flutuante a ser comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int Compara(float texto);
  /**
   *@param texto é um número de ponto flutuante a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int Compara(float texto, const char* formato);
  /**
   *@param texto é um número inteiro longo a ser comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int Compara(long texto);
  /**
   *@param texto é um número inteiro longo a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int Compara(long texto, const char* formato);


  // ComparaIgnoreCase: Compara o texto desta string com 'texto' desconsiderando se é minúscula ou maiúscula
  /**
   *@param texto a ser comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int ComparaIgnoreCase(const char* texto);
  /**
   *@param texto terá seu valor(texto.Texto()) comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int ComparaIgnoreCase(String &texto);
  /**
   *@param texto é um caractere a ser comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int ComparaIgnoreCase(char texto);
  /**
   *@param texto é um número inteiro a ser comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int ComparaIgnoreCase(int texto);
  /**
   *@param texto é um número inteiro a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int ComparaIgnoreCase(int texto, const char* formato);
  /**
   *@param texto é um número de dupla precisão a ser comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int ComparaIgnoreCase(double texto);
  /**
   *@param texto é um número de dupla precisão a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int ComparaIgnoreCase(double texto, const char* formato);
  /**
   *@param texto é um número de ponto flutuante a ser comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int ComparaIgnoreCase(float texto);
  /**
   *@param texto é um número de ponto flutuante a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int ComparaIgnoreCase(float texto, const char* formato);
  /**
   *@param texto é um número inteiro longo a ser comparado com o valor desta string
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int ComparaIgnoreCase(long texto);
  /**
   *@param texto é um número inteiro longo a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return -1 caso for menor, 0 caso for igual, 1 caso for maior
   */
  int ComparaIgnoreCase(long texto, const char* formato);



  // Igual: Compara o texto desta string com 'texto' para ver se são iguais
  /**
   *@param texto a ser comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool Igual(const char* texto);
  /**
   *@param texto terá seu valor(texto.Texto()) comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool Igual(String &texto);
  /**
   *@param texto é um caractere a ser comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool Igual(char texto);
  /**
   *@param texto é um número inteiro a ser comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool Igual(int texto);
  /**
   *@param texto é um número inteiro a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool Igual(int texto, const char* formato);
  /**
   *@param texto é um número de dupla precisão a ser comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool Igual(double texto);
  /**
   *@param texto é um número de dupla precisão a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool Igual(double texto, const char* formato);
  /**
   *@param texto é um número de ponto flutuante a ser comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool Igual(float texto);
  /**
   *@param texto é um número de ponto flutuante a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool Igual(float texto, const char* formato);
  /**
   *@param texto é um número inteiro longo a ser comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool Igual(long texto);
  /**
   *@param texto é um número inteiro longo a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool Igual(long texto, const char* formato);



  // IgualIgnoreCase: Compara o texto desta string com 'texto' para ver se são iguais, desconsiderando minúsculas e maiúsculas
  /**
   *@param texto a ser comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool IgualIgnoreCase(const char* texto);
  /**
   *@param texto terá seu valor(texto.Texto()) comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool IgualIgnoreCase(String &texto);
  /**
   *@param texto é um caractere a ser comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool IgualIgnoreCase(char texto);
  /**
   *@param texto é um número inteiro a ser comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool IgualIgnoreCase(int texto);
  /**
   *@param texto é um número inteiro a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool IgualIgnoreCase(int texto, const char* formato);
  /**
   *@param texto é um número de dupla precisão a ser comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool IgualIgnoreCase(double texto);
  /**
   *@param texto é um número de dupla precisão a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool IgualIgnoreCase(double texto, const char* formato);
  /**
   *@param texto é um número de ponto flutuante a ser comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool IgualIgnoreCase(float texto);
  /**
   *@param texto é um número de ponto flutuante a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool IgualIgnoreCase(float texto, const char* formato);
  /**
   *@param texto é um número inteiro longo a ser comparado com o valor desta string
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool IgualIgnoreCase(long texto);
  /**
   *@param texto é um número de inteiro longo a ser comparado com o valor desta string
   *@param formato formato no modelo 'printf' o qual será usado na conversão do número
   *@return true caso forem iguais, false caso forem diferentes
   */
  bool IgualIgnoreCase(long texto, const char* formato);

  
  /**
   * Vazia: retorna true se está vazia, false caso contrário
   *@return true caso esteja vazia, false caso contrário
   */
  bool Vazia();

  /**
   * Localizacao: muda a localização(língua,etc) para o locale especificado
   *@param locale o locale desejado (man locale), por exemplo "pt_BR". Se usar um vazio(""), será usada a variável de ambiente $LC_ALL ou então $LANG
   */
  void Localizacao(const char* locale);


  /**
   * Para_Int: tenta retornar a string como um 'int'. Se der errado, retorna 0
   */
  int Para_Int();
  /**
   * Para_Double: tenta retornar a string como um 'double'. Se der errado, retorna 0
   */
  double Para_Double();
  /**
   * Para_Long: tenta retornar a string como um 'long'. Se der errado, retorna 0
   */
  long Para_Long();


  /**
   * Quebra: quebra a string onde for encontrado o 'delimitador'. O resultado é retornado em uma lista de strings.
   *@return Lista_Simples<String> *, na ordem. Memória dinâmica, favor liberar depois.
   */
  Lista_Simples<String> *Quebra(char delimitador);


  //Operadores:
  /**
   * Operador=: Atribuição.
   * Use str = texto ao invés de chamar str.Muda_Texto(texto)
   */
  String &operator=(const char *texto);
  String &operator=(const String &texto);
  String &operator=(char texto);
  String &operator=(int texto);
  String &operator=(double texto);
  String &operator=(float texto);
  String &operator=(long texto);

  /**
   * Operador+: Concatena
   * Use str = str2 + texto ao invés de chamar str = str2; str.Concatena(texto)
   */
  String operator+(const char *texto);
  String operator+(const String texto);
  String operator+(char texto);
  String operator+(int texto);
  String operator+(double texto);
  String operator+(float texto);
  String operator+(long texto);

  /**
   * Operador+=: Concatena e Atribui
   * Use str += texto ao invés de chamar str.Concatena(texto)
   */
  String &operator+=(const char *texto);
  String &operator+=(String texto);
  String &operator+=(char texto);
  String &operator+=(int texto);
  String &operator+=(double texto);
  String &operator+=(float texto);
  String &operator+=(long texto);


  /**
   * Operador==: Compara
   */
  bool operator==(const char *texto);
  bool operator==(String texto);
  bool operator==(char texto);
  bool operator==(int texto);
  bool operator==(double texto);
  bool operator==(float texto);
  bool operator==(long texto);

  /**
   * Operador<: Compara
   */
  bool operator<(const char *texto);
  bool operator<(String texto);
  bool operator<(char texto);
  bool operator<(int texto);
  bool operator<(double texto);
  bool operator<(float texto);
  bool operator<(long texto);

  /**
   * Operador>: Compara
   */
  bool operator>(const char *texto);
  bool operator>(String texto);
  bool operator>(char texto);
  bool operator>(int texto);
  bool operator>(double texto);
  bool operator>(float texto);
  bool operator>(long texto);

  /**
   * Operador<=: Compara
   */
  bool operator<=(const char *texto);
  bool operator<=(String texto);
  bool operator<=(char texto);
  bool operator<=(int texto);
  bool operator<=(double texto);
  bool operator<=(float texto);
  bool operator<=(long texto);

  /**
   * Operador>=: Compara
   */
  bool operator>=(const char *texto);
  bool operator>=(String texto);
  bool operator>=(char texto);
  bool operator>=(int texto);
  bool operator>=(double texto);
  bool operator>=(float texto);
  bool operator>=(long texto);

  /**
   * Operador!=: Compara
   */
  bool operator!=(const char *texto);
  bool operator!=(String texto);
  bool operator!=(char texto);
  bool operator!=(int texto);
  bool operator!=(double texto);
  bool operator!=(float texto);
  bool operator!=(long texto);

  
protected:
  char *texto;
  
};

#endif