package Subtitle::MSub;

use strict;
use warnings;
use utf8;

use Subtitle::Utils qw(:string round);

use base 'Subtitle::BASE';

sub new {
  my ($class, %args) = @_;
  my $self = {
    debug  => 0,
    eol    => "\n",
    fps    => undef,
    default_fps    => 25.0,
    convert_timing => 1,
    %args,
    events => [],
    log    => [],
  };

  return bless($self, $class);
}

sub new_event { return +{ timing => undef, text => undef }; }

sub parse {
  my ($self, $lines) = @_;
  my $linenum = 0;
  my $event;

  foreach my $line (@{ $lines }) {
    $linenum++;
    chomp_all($line);
    trim($line);
    next unless $line;
    my ($start, $end, $rest) = ($line =~ m/{(\d+)}\s*{(\d+)}\s*(.+)/o);
    # expected: garbage
    unless ($start and $end and $rest) {
      $self->log(warn => "Unrecognized line at $linenum: $line");
      next;
    }
    # expected: valid line
    # special case - '{1}{1}XX.YY' line sets fps
    if ($start == 1 and $end == 1) {
      my ($fps) = ($rest =~ m/(\d+(?:\.\d+))/o);
      unless ($fps) {
        $self->log(error => "Expected fps at line $linenum, but found: $rest");
        next;
      }
      if ($fps and $self->{fps}) {
        $self->log(warn => "Found fps line at $linenum, but fps already set by user");
        next;
      }
      $self->log(debug => "Set fps to $fps and line $linenum");
      $self->{fps} = $fps;
      next;
    }
    trim($rest);
    $rest =~ s/\|/$self->{eol}/og;
    my $event = $self->new_event;
    $event->{timing} = [$start, $end];
    $event->{text}   = $rest;
    push @{ $self->{events} }, $event;
    undef $event;
  }
  # set fps if none and recalc timing
  $self->{fps} //= $self->{default_fps};
  return scalar @{ $self->{events} }
    unless $self->{convert_timing};

  $self->log(debug => "Converting frame numbers to time with fps $self->{fps}");
  foreach my $event (@{ $self->{events} }) {
    $event->{timing}->[0] /= $self->{fps};
    $event->{timing}->[1] /= $self->{fps};
  }

  return scalar @{ $self->{events} };
}

sub build {
  my ($self) = @_;
  my @lines;

  push @lines, sprintf "{1}{1}%.3f", $self->{fps};
  foreach my $e (@{ $self->{events} }) {
    my $show = round($e->{timing}->[0] * $self->{fps}, 0);
    my $hide = round($e->{timing}->[1] * $self->{fps}, 0);
    my $text = ($e->{text} =~ s{$self->{eol}}{|}gr);
    push @lines, sprintf "{%d}{%d}%s", $show, $hide, $text;
  }
  push @lines, "";

  return join($self->{eol} => @lines);
}

1;

=pod

=head1 NAME

Subtitle::MSub -- micsrosub subtitle format

=head1 METHODS

=head2 C<new>

  my $msub = Subtitle::MSub->new(%opts);

Creates new object, takes list of options as argument.
Recognized keys are:

* debug -- write debug messages to log (default: 0)
* eol   -- replace "|" symbol within subtitle text with this chars (default: "\n")
* fps   -- sets FPS for subtitle (default: not set, try detect from file, then use default)
* default_fps -- FPS for subtitle, if not found in file, and not set by user (default: 25.0)
* convert_timing -- convert frame numbers to seconds (default: 1)

=head2 C<parse>

  my $events_count = $msub->parse(\@lines);

Parse subtitle from array of lines.
Returns parsed events count on success, -1 on error

=head2 C<build>

  my $text = $msub->build();

Builds parsed subtitle to string.

=cut