package ws;
use Dancer ':syntax';

use FL3 'pt';
use Lingua::FreeLing3::Sentence;
use Lingua::FreeLing3::Utils qw/word_analysis/;
use Lingua::Jspell;
use LWP::UserAgent;
use Data::Dumper;

our $VERSION = '0.1';

my $jspell_dict = Lingua::Jspell->new("pt_PT");

my $fl3_morph_pt = Lingua::FreeLing3::MorphAnalyzer->new('pt',
    ProbabilityAssignment  => 0, QuantitiesDetection    => 0,
    MultiwordsDetection    => 0, NumbersDetection       => 0,
    DatesDetection         => 0, NERecognition          => 0,
  );

get '/' => sub {
  template 'index';
};

get '/demo' => sub {
  template 'demo';
};

post '/demo' => sub {
  my $req = param 'request';
  my $text = param 'text';

  my $url = 'http://api.natura.di.uminho.pt';
  my $ua = new LWP::UserAgent(timeout => 300);
  my $response = $ua->post("$url$req", {text=>$text} );

  my $result = '';
  $result =  $response->content if( $response->is_success );

  template 'demo' => { res => $result };
};

post '/tokenizer' => sub {
  forward '/fl3/tokenizer';
};

post '/fl3/tokenizer' => sub {
  my $text = param 'text';
  my $tokens = _fl3_tokenizer($text);
  return to_json $tokens;
};

get '/analyzer/:word' => sub {
  my $word = param 'word';

  forward "/fl3/analyzer/$word";
};

get '/fl3/analyzer/:word' => sub {
  my $word = param 'word';

  my %options = ( lang=>'pt' );
  my $result = _fl3_analyzer_word($word, %options);

  return to_json $result;
};

get '/jspell/analyzer/:word' => sub {
  my $word = param 'word';

  my %options = ( lang=>'pt' );
  my $result = _jspell_analyzer_word($word, %options);

  return to_json $result;
};

post '/analyzer' => sub {
  forward '/fl3/analyzer';
};

post '/fl3/analyzer' => sub {
  my $text = param 'text';
  my $ner = param('ner') ? param('ner') : 0 ;
  my %options = ( lang => 'pt', ner => $ner );

  my $result = _fl3_analyzer($text, %options);

  return to_json $result;
};

sub _fl3_analyzer {
  my ($text, %options) = @_;
  return unless $text;

  my $morph = Lingua::FreeLing3::MorphAnalyzer->new($options{lang},
      NERecognition => $options{ner},
    );

  my $tokens = tokenizer->tokenize($text);
  my $sentences = splitter->split($tokens);
  $sentences = $morph->analyze($sentences);
  $sentences = hmm->analyze($sentences);

  my $result;
  foreach (@$sentences) {
    my @words = $_->words;
    foreach my $w (@words) {
      push @$result, {word=>$w->form, pos=>$w->tag, lemma=>$w->lemma};
    }
  }

  return $result;
}

sub _fl3_analyzer_word {
  my ($word, %options) = @_;
  return unless $word;

  # FIXME FL3::Utils -- OrthographicCorrection
  #my $result = word_analysis({ l=>$options{lang} }, $word);

  my $words = tokenizer($options{lang})->tokenize($word);
  
  my $analysis = $fl3_morph_pt->analyze([Lingua::FreeLing3::Sentence->new(@$words)]);
  my @w = $analysis->[0]->words;
  my $result =  $w[0]->analysis(FeatureStructure=>1);

  my @final;
  foreach (@$result) {
    my $pos = $_->{tag};
    my $lemma = $_->{lemma};
    my $cat = '_';
    $cat = lc($1) if $pos =~ m/^(\w)/;
    push @final, {lemma=>$lemma, pos=>$pos, cat=>$cat, word=>$word};
  }

  return [@final];
}

sub _jspell_analyzer_word {
  my ($word, %options) = @_;

  my $result;

  foreach ( $jspell_dict->featagsrad($word) ) {
    my ($pos, $lemma) = split /:/, $_;
    my $cat = '_';
    $cat = lc($1) if $pos =~ m/^(\w)/;
    push @$result, {lemma=>$lemma, pos=>$pos, cat=>$cat, word=>$word};
  }

  return $result;
}

sub _fl3_tokenizer {
  my ($text) = @_;
  return unless $text;

  my $pt_tok = Lingua::FreeLing3::Tokenizer->new("pt");
  my $tokens = $pt_tok->tokenize($text, to_text => 1);

  return $tokens;
}

true;