/* 
 *	Copyright (C) 2004-2005 Vadim Berezniker
 *	http://www.kryptolus.com
 *
 *  This Program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *   
 *  This Program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *   
 *  You should have received a copy of the GNU General Public License
 *  along with GNU Make; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
 *  http://www.gnu.org/copyleft/gpl.html
 *
 */
#include "stdafx.h"

#include "common.h"

#include "sabbu.h"

#include "kryString.h"

#include "kryArray.h"

#include "krySSACommandParser.h"


extern struct sabbu app;

void krySSACommandParser::ParseParameterList(kryString & param, kryArray<kryString> & params, kryArray<int> & param_offsets, int offset)
{
  while(!param.IsEmpty())
  {
    int i = param.Find(','), j = param.Find('\\');

    if(i >= 0 && (j < 0 || i < j))
    {
      kryString s = param.Left(i);
      if(!s.IsEmpty())
      {
        this->OnCommandParameter(s);
      }

      if(!s.Trim().IsEmpty())
      {
        params.Add(s.Trim());
        param_offsets.Add(offset);
      }

      offset += (i + 1);
      param = param.Mid(i+1);
      this->OnCommandParameterSeparator(",");
    }
    else
    {
      this->OnCommandParameter(param);
      param_offsets.Add(offset);
      param.Trim();
      if(!param.IsEmpty()) 
        params.Add(param);

      param.Empty();
    }
  }
}

void krySSACommandParser::ParseCommandIntoParameters(kryString & cmd, kryArray<kryString> &params, kryArray<int> &param_offsets, int offset)
{
  cmd = cmd.Mid(1);
  offset++;

  if(!cmd.Find("1c") || !cmd.Find("2c") || !cmd.Find("3c") || !cmd.Find("4c"))
  {
    params.Add(cmd.Mid(2).Trim("&H")), cmd = cmd.Left(2);
    param_offsets.Add(offset + 2);
  }
  else if(!cmd.Find("1a") || !cmd.Find("2a") || !cmd.Find("3a") || !cmd.Find("4a"))
  {
    params.Add(cmd.Mid(2).Trim("&H")), cmd = cmd.Left(2);
    param_offsets.Add(offset + 2);
  }
  else if(!cmd.Find("alpha"))
  {
    params.Add(cmd.Mid(5).Trim("&H")), cmd = cmd.Left(5);
    param_offsets.Add(offset + 5);
  }
  else if(!cmd.Find("an"))
  {
    params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
    param_offsets.Add(offset + 2);
  }
  else if(!cmd.Find("a"))
  {
    params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
    param_offsets.Add(offset + 1);
  }
  else if(!cmd.Find("bord"))
  {
    params.Add(cmd.Mid(4)), cmd = cmd.Left(4);
    param_offsets.Add(offset + 4);
  }
  else if(!cmd.Find("be"))
  {
    params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
    param_offsets.Add(offset + 2);
  }
  else if(!cmd.Find("b"))
  {
    params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
    param_offsets.Add(offset + 1);
  }
  else if(!cmd.Find("clip"))
    ;
  else if(!cmd.Find("c"))
  {
    params.Add(cmd.Mid(1).Trim("&H")), cmd = cmd.Left(1);
    param_offsets.Add(offset + 1);
  }
  else if(!cmd.Find("fade"))
    ;
  else if(!cmd.Find("fe"))
  {
    params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
    param_offsets.Add(offset + 2);
  }
  else if(!cmd.Find("fn"))
  {
    params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
    param_offsets.Add(offset + 2);
  }
  else if(!cmd.Find("frx") || !cmd.Find("fry") || !cmd.Find("frz"))
  {
    params.Add(cmd.Mid(3)), cmd = cmd.Left(3);
    param_offsets.Add(offset + 3);
  }
  else if(!cmd.Find("fr"))
  {
    params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
    param_offsets.Add(offset + 2);
  }
  else if(!cmd.Find("fscx") || !cmd.Find("fscy"))
  {
    params.Add(cmd.Mid(4)), cmd = cmd.Left(4);
    param_offsets.Add(offset + 4);
  }
  else if(!cmd.Find("fsc"))
  {
    params.Add(cmd.Mid(3)), cmd = cmd.Left(3);
    param_offsets.Add(offset + 3);
  }
  else if(!cmd.Find("fsp"))
  {
    params.Add(cmd.Mid(3)), cmd = cmd.Left(3);
    param_offsets.Add(offset + 3);
  }
  else if(!cmd.Find("fs"))
  {
    params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
    param_offsets.Add(offset + 2);
  }
  else if(!cmd.Find("i"))
  {
    params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
    param_offsets.Add(offset + 1);
  }
  else if(!cmd.Find("kf") || !cmd.Find("ko"))
  {
    params.Add(cmd.Mid(2)), cmd = cmd.Left(2);
    param_offsets.Add(offset + 2);
  }
  else if(!cmd.Find("k") || !cmd.Find("K"))
  {
    params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
    param_offsets.Add(offset + 1);
  }
  else if(!cmd.Find("move"))
    ;
  else if(!cmd.Find("org"))
    ;
  else if(!cmd.Find("pbo"))
  {
    params.Add(cmd.Mid(3)), cmd = cmd.Left(3);
    param_offsets.Add(offset + 3);
  }
  else if(!cmd.Find("pos"))
    ;
  else if(!cmd.Find("p"))
  {
    params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
    param_offsets.Add(offset + 1);
  }
  else if(!cmd.Find("q"))
  {
    params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
    param_offsets.Add(offset + 1);
  }
  else if(!cmd.Find("r"))
  {
    params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
    param_offsets.Add(offset + 1);
  }
  else if(!cmd.Find("shad"))
  {
    params.Add(cmd.Mid(4)), cmd = cmd.Left(4);
    param_offsets.Add(offset + 4);
  }
  else if(!cmd.Find("s"))
  {
    params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
    param_offsets.Add(offset + 1);
  }
  else if(!cmd.Find("t"))
    ;
  else if(!cmd.Find("u"))
  {
    params.Add(cmd.Mid(1)), cmd = cmd.Left(1);
    param_offsets.Add(offset + 1);
  }
}

void krySSACommandParser::ParseSSATag(kryString str, int offset, gboolean in_parenthesis)
{
  this->OnCommandGroupStart(in_parenthesis ? "{" : "", offset - 1);

  int prev_command_end = 0;
  gunichar c;
  int i, j;

  for(i = 0; ; i = j)
  {
    j = str.Find('\\', i);

    if(j == -1 && prev_command_end != str.GetLength())
    {
      kryString unparsed = str.Mid(prev_command_end);
      this->OnCommandUnparsed(unparsed);
    }

    if(j == -1)
      break;

    if(prev_command_end < j)
    {
      kryString unparsed = str.Mid(prev_command_end, j - prev_command_end);
      this->OnCommandUnparsed(unparsed);
    }

    int cmd_start = j;
    kryString cmd;
    for(c = str[j]; c && c != '(' && (cmd.GetLength() == 0 || c != '\\'); cmd += c, c = str[++j]);
    if(cmd.GetLength() == 1) continue;

    this->OnCommandText(cmd);

    kryArray<kryString> params;
    kryArray<int> param_offsets;

    if(str[j] == '(')
    {
      this->OnCommandParameterStart("(");

      kryString param;
      int param_list_start = j + 1;
      for(c = str[++j]; c && c != ')'; param += c, c = str[++j]);
      this->ParseParameterList(param, params, param_offsets, offset + param_list_start);

      if(c == ')')
      {
        this->OnCommandParameterEnd(")");
        j++;
      }

    }

    this->ParseCommandIntoParameters(cmd, params, param_offsets, offset + cmd_start);

    this->OnCommandEnd();

    this->OnCommand(cmd, offset + cmd_start, j - cmd_start, params, param_offsets);
    prev_command_end = j;
  }

  this->OnCommandGroupEnd(in_parenthesis ? "}" : "", str.GetLength());
}

void krySSACommandParser::ParseSubtitleString(kryString str)
{
  int offset = 0;
  while(!str.IsEmpty())
  {
    bool notTag = true;

    int i;

    if(str[0] == '{' && (i = str.Find('}')) > 0)
    {
      ParseSSATag(str.Mid(1, i-1), offset + 1, TRUE);
      str = str.Mid(i+1);
      offset += (i + 1);
      notTag = false;
    }

    i = str.Find('{');
    if(i < 0) i = str.GetLength();
    if(i == 0 && notTag) i++;


    kryString text = str.Left(i);
    OnString(text, offset);

    str = str.Mid(i);
    offset += i;
  }
}