/**
 *
 * 女医ハックデータ（フレーズ）パーサ
 * Copyright (C) 2008 id:yuaaaa
 *
 * $Id$
 */

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;

namespace JoyHack
{
    public class Phrase
    {
        private Timecode _endtime, _appeartime = null, _diapptime=null;
        public List<Word> words;

        public int showline;
        public int all_showline;
        public float height; //基準height : <clear>直後フレーズのMaxHeight。
        public Alignment align;
        public bool clear;

        private bool _strict;
        
        protected Timecode endtime
        {
            get { return this._endtime; }
            set { this._endtime = value; }
        }

        public Timecode appearTime
        {
            get { return this._appeartime; }
            set { this._appeartime = value; }
        }

        public Timecode disappTime
        {
            get { return this._diapptime; }
            set { this._diapptime = value; }
        }

        public bool strict { get { return this._strict; } protected set { this._strict = value; } }

        public Phrase(string line, int showline, int all_showline,
            ref WordCond cond, Alignment align, Timecode prev_endtime, bool strict)
        {
            line.Replace("\r","");
            line.Replace("\n","");

            if (line.IndexOf("<time>") < 0)
            {
                throw new Exception("非<time>行でPhraseがコールされました");
            }

            this.showline = showline;
            this.all_showline = all_showline;
            this.align = align;
            this.clear = false;
            this.strict = strict;
            
            this.words = new List<Word>();
            
            string[] token = line.Split(new char[] { '\t' });
            if ( token.Length == 1 ) {
                throw new JoyHackDataException("トークンが1つしかありません", true );
            }
            
            int i;
            Timecode lasttime = prev_endtime;

            for ( i=0; i< token.Length; i++ )
            {
                
                if (token[i].StartsWith("<time>"))
                {
                    if (i == 0)
                    {
                        throw new JoyHackDataException("ワードが1つもありません", true);
                    }
                    this.words[0].time = this.TimeFromString(token[i].Remove(0, "<time>".Length), ref lasttime);
                    i++;
                    break;
                }

                if (this.clear && this.strict)
                {
                    throw new JoyHackDataException("<clear>タグ以降に別のワードがあります");
                }

                cond.reset(); //その場しのぎcondの解除

                if ( token[i].IndexOf("<clear>") >= 0 )
                {
                    if (i != 0 && this.strict)
                    {
                        throw new JoyHackDataException("<clear>タグ以前に別のワードがあります");
                    }
                    this.clear = true;
                    token[i] = token[i].Substring(token[i].IndexOf("<clear>") + "<clear>".Length);
                    int newline = this.all_showline;
                    if ( token[i] != "" ) {
                        try {
                            newline = Int32.Parse(token[i]);
                        } catch ( Exception e ) {
                            if (this.strict)
                            {
                                throw new JoyHackDataException("<clear>タグの行数指定が不正です (" + e.Message + ") : \"" + token[i] + "\"");
                            }
                        }

                        if (1 <= newline && newline <= 4)
                        {
                            this.all_showline = newline;
                        } else {
                            throw new JoyHackDataException("<clear>タグの行数指定が誤っています: \"" + token[i] + "\"");
                        }
                    }

                    token[i] = ""; //いちお
                }

                string[] tagArray = token[i].Split(new char[] { '<' });
                string mainText = tagArray[0];
                string ruby = null;

                bool firsttagtoken = true;
                foreach (string s in tagArray)
                {
                    if (firsttagtoken)
                    {
                        firsttagtoken = false;
                        continue;
                    }

                    if (s.StartsWith("image>")) { continue; }
                    if (s.StartsWith("skip>")) { continue; }
                    if (s.StartsWith("color>"))
                    {
                        string colorstr = s.Substring("color>".Length);
                        cond.color = ShowColor.MakeFromString(colorstr, cond.color);
                        continue;
                    }
                    if (s.StartsWith("ruby>"))
                    {
                        ruby = s.Substring("ruby>".Length);
                        continue;
                    }

                    #region 独自拡張
                    
                    if (s.StartsWith("x_font>"))
                    {
                        string fontstr = s.Substring("x_font>".Length);
                        cond.mainfont = WordFont.MakeFromString(cond.mainfont, fontstr);
                        cond.syncRubyFont();
                        continue;
                    }

                    if (s.StartsWith("x_mainfont>"))
                    {
                        string fontstr = s.Substring("x_mainfont>".Length);
                        cond.mainfont = WordFont.MakeFromString(cond.mainfont, fontstr);
                        continue;
                    }

                    if (s.StartsWith("x_rubyfont>"))
                    {
                        string fontstr = s.Substring("x_rubyfont>".Length);
                        cond.rubyfont = WordFont.MakeFromString(cond.rubyfont, fontstr);
                        continue;
                    }

                    if (s.StartsWith("x_width>"))
                    {
                        string widthstr = s.Substring("x_width>".Length);

                        try
                        {
                            cond.width = int.Parse(widthstr);
                        }
                        catch
                        {
                            throw new JoyHackDataException("不正な<x_width>です: \"" + widthstr + "\"");
                        }

                        continue;
                    }

                    //UNUSED
                    /*
                    if (s.StartsWith("x_ypos>"))
                    {
                        string widthstr = s.Substring("x_ypos>".Length);
                        cond.ypos = int.Parse(widthstr);
                        continue;
                    }
                    */
                    #endregion

                    if (ruby != null) { ruby += "<" + s; }
                    else { mainText += "<" + s; }
                    
                }

                this.words.Add ( new Word( mainText, ruby,this, cond ) );

                if (this.words.Count == token.Length)
                {
                    throw new JoyHackDataException("<time>で始まるトークンが見つかりません");
                }
            }

            if (i + this.words.Count > token.Length) {
                if (this.strict)
                {
                    throw new JoyHackDataException("ワード数に対してタイムコードが不足しています");
                }

                //不足分を最終タイムコードで埋める
                int padtc_count = i + this.words.Count - token.Length;
                List<string> padtc_temp = new List<string>(token);

                string padder;
                if (token.Length - this.words.Count <= 1)
                {
                    //タイムコードがいっこしかない
                    padder = this.words[0].time.ToString();
                }
                else
                {
                    padder = token[token.Length - 1];
                }

                for (int padtc = 0; padtc < padtc_count; padtc++)
                {
                    padtc_temp.Add(padder);
                }

                token = padtc_temp.ToArray();
            }

            if (i + this.words.Count < token.Length) {
                if (this.strict)
                {
                    throw new JoyHackDataException("タイムコード数に対してワードが不足しています");
                }
            }

            for ( int j=1; j<this.words.Count; i++, j++ )
            {
                this.words[j].time = this.TimeFromString(token[i],ref lasttime);
            }

            this.endtime = this.TimeFromString(token[i], ref lasttime);

        }

        private Timecode TimeFromString(string timestr, ref Timecode lasttime)
        {
            if (timestr == "") { return lasttime; }
            Timecode tc = new Timecode(timestr);
            lasttime = tc;
            return tc;
        }

        public float GetRealHeight(float height)
        {
            return height * 1.5f;
        }

        public int GetDrawHeight()
        {
            return (int)this.GetRealHeight(this.GetMaxHeight() * 1.7f);
        }

        public float GetTerritoryHeight()
        {
            return this.GetRealHeight(this.GetMaxHeight() * 1.8f);
        }

        public float GetMaxHeight()
        {
            float maxh = 0F;
            foreach (Word w in this.words)
            {
                maxh = System.Math.Max(maxh, 
#if PocketPC
                    (int)(20 * 96 / 72)
#else
                    w.cond.mainfont.font.GetHeight()
#endif
                    );
            }
            return maxh;
        }

        //public float 

        public Timecode getStarttime()
        {
            return this.words[0].time;
        }

        public Timecode getEndtime()
        {
            return this.endtime;
        }

        public Timecode getWordEnd(int wordnum)
        {
            if (wordnum + 1 >= this.words.Count)
            {
                return this.endtime;
            }
            else
            {
                return this.words[wordnum + 1].time;
            }
        }

        public Timecode getWordEnd(Word w)
        {
            int ind = this.words.IndexOf(w);
            if (ind < 0) { throw new JoyHackDataException("指定されたワードが見つかりません"); }
            return this.getWordEnd(ind);
        }

        public bool checkTimeRange(Timecode time)
        {
            return (this.getStarttime() <= time && time <= this.getEndtime());
        }

        public Word getWordFromTime(Timecode time)
        {
            if (!this.checkTimeRange(time)) { return null; }
            for ( int i = this.words.Count; i > 0; i-- )
            {
                if (this.words[i-1].time <= time)
                {
                    return this.words[i-1];
                }
            }
            return null;
        }

        public string getPhraseString()
        {
            if (this.clear) { return ""; }
            string ret = "";
            foreach (Word w in this.words)
            {
                ret += w.str;
            }
            return ret;
        }

        public override string ToString()
        {
            return this.getPhraseString();
        }

    }

    
    public class Word
    {
        public string str;
        public string ruby; //null: hasn't ruby

        private readonly Phrase _phr;
        public Timecode time;
        public WordCond cond;

        public Word(string wordstr, string ruby, Phrase phr, WordCond cond)
        {
            this.str = wordstr;
            this.ruby = ruby;
            this._phr = phr;
            this.cond = cond;
        }

        public Phrase GetBelongPhrase() { return this._phr; }

        public override string ToString()
        {
            return this.str;
        }
    }

    public partial class Timecode : IComparable<Timecode>
    {
        private int _min = 0;
        private int _sec = 0;
        private int _frame = 0; //1sec = 60frames

        public int min
        {
            get { return this._min; }
            set
            {
                if (value < 0) { throw new JoyHackDataException("分が不正な値です"); }
                this._min = value;
            }
        }

        public int sec
        {
            get { return this._sec; }
            set
            {
                if (value < 0 || 59 < value) { throw new JoyHackDataException("秒が不正な値です"); }
                this._sec = value;
            }
        }

        public int frame
        {
            get { return this._frame; }
            set
            {
                if (value < 0 || 60 < value) { throw new JoyHackDataException("フレーム数が不正な値です"); }
                this._frame = value;
            }
        }

        public int allFrames
        {
            get { return this.min * 60 * 60 + this.sec * 60 + this.frame; }
            set
            {
                this.min = (int)(value / (60 * 60));
                this.sec = (int)((value % (60 * 60)) / 60);
                this.frame = (int)(value % 60);                
            }
        }


        public Timecode(string timestr)
        {

            string[] a = timestr.Split(new char[] { ':' });
            if (a.Length != 3) { throw new JoyHackDataException("不正なタイムコードです: \"" + timestr + "\""); }
            try
            {
                this.min = Int32.Parse(a[0]);
                this.sec = Int32.Parse(a[1]);
                this.frame = Int32.Parse(a[2]);
            }
            catch (Exception e)
            {
                throw new JoyHackDataException("不正なタイムコードです(" + e.Message + ") : \"" + timestr + "\"");
            }
        }

        public Timecode(int frames)
        {
            this.allFrames = frames;
        }

        public Timecode(int min, int sec, int frame)
        {
            this.min = min;
            this.sec = sec;
            this.frame = frame;
        }

        public static Timecode FromMillisecond(long ms)
        {
            Timecode t = new Timecode(
                (int)(ms / (1000 * 60)),
                (int)((ms % (1000 * 60)) / 1000),
                (int)((ms % 1000)*(60/1000f))
            );
            return t;
        }

        public static Timecode getInfinity()
        {
            return new Timecode(int.MaxValue);
        }

        public int CompareTo(Timecode other)
        {
            return this.allFrames - other.allFrames;
        }

        public override string ToString() {
            return this.min.ToString().PadLeft(2, '0') + ":"
                + this.sec.ToString().PadLeft(2, '0') + ":" + this.frame.ToString().PadLeft(2, '0');
        }
    }

    #region Mix-in Comparable: Timecode
    partial class Timecode : IComparable<Timecode>
    {
        public static bool operator <(Timecode lhs, Timecode rhs)
        {
            if(lhs.CompareTo(rhs) < 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
 
        public static bool operator <=(Timecode lhs, Timecode rhs)
        {
            if(lhs.CompareTo(rhs) <= 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
 
        public static bool operator >(Timecode lhs, Timecode rhs)
        {
            if(lhs.CompareTo(rhs) > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
 
        public static bool operator >=(Timecode lhs, Timecode rhs)
        {
            if(lhs.CompareTo(rhs) > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }
    #endregion
    
    //[塗り前],[縁取の塗り前],[塗り後],[縁取の塗り後],[ルビ塗り前],[ルビ縁取の塗り前],[ルビ塗り後],[ルビ縁取の塗り後]
    public class ShowColor : ICloneable
    {
        public System.Drawing.Color[] colors = new System.Drawing.Color[8];

        public System.Drawing.Color this[int i]
        {
            set {
                if ( i < 0 || 8 <= i ) { throw new IndexOutOfRangeException(); }
                this.colors[i] = value;
            }

            get {
                if ( i < 0 || 8 <= i ) { throw new IndexOutOfRangeException(); }
                return this.colors[i];
            }
        }

        public ShowColor() { }

        public ShowColor ( System.Drawing.Color[] colors )
        {
            if (colors.Length != 8) { throw new ArgumentException(); }
            this.colors = colors;
        }

        public static ShowColor MakeFromString(string colorstr, ShowColor original)
        {
            ShowColor sc = (ShowColor)original.Clone();
            string[] colors_str = colorstr.Split(new char[] { ',' });
            if (colors_str.Length != 8) { throw new JoyHackDataException("不正なカラーコードです: "+ colorstr); }

            for (int i = 0; i < 8; i++)
            {
                try
                {
                    sc.colors[i] = ShowColor.setColor(colors_str[i], original.colors[i]);
                }
                catch
                {
                    throw new JoyHackDataException("不正な色指定（" + (i + 1).ToString() + "個目）です: " + colors_str[i]);
                }
            }
            return sc;
        }

        public static System.Drawing.Color setColor(string str, System.Drawing.Color old)
        {
            if (str == "")
            {
                return old;
            }

#if PocketPC
#if DEBUG
#warning TODO: FIXME!!
            return old;
#else
#error FIXME
#endif

#else
            return System.Drawing.ColorTranslator.FromHtml("0x" + str);
#endif
        }

        public object Clone()
        {
            ShowColor sc = new ShowColor();

            sc.colors = (System.Drawing.Color[])this.colors.Clone();
            sc.colors[0] = System.Drawing.Color.Yellow;

            return sc;
        }

        public override string ToString()
        {
            string ret = "";
            for (int i = 0; i < 8; i++)
            {
                ret += string.Format("{0,0:X2}{1,0:X2}{2,0:X2}"
                    , this.colors[i].R, this.colors[i].G, this.colors[i].B);
                ret += ",";
            }
            return ret.Remove(ret.Length - 1, 1 );
        }

    }

    // <font>FamilyName[,emSize[,style[,unit[,line_align[,adjust_width]]]]]
    public class WordFont : ICloneable
    {
        public System.Drawing.Font font;
        public System.Drawing.StringAlignment line_align;
        public double adjust_width;

        public WordFont(System.Drawing.Font font, System.Drawing.StringAlignment halign)
            : this(font, halign, 1.0D )
        {}

        public WordFont(System.Drawing.Font font, System.Drawing.StringAlignment halign, double adjust_width)
        {
            this.font = font;
            this.line_align = halign;
            this.adjust_width = adjust_width;
        }

        public object Clone()
        {
            WordFont wf = new WordFont((System.Drawing.Font)font.Clone(), line_align, adjust_width);
            return wf;
        }

        public static WordFont MakeFromString(WordFont original, string fontstr)
        {
            string[] font_arr = fontstr.Split(new char[] { ',' });

            string fontname = original.font.Name;
            if (font_arr[0] != "") { fontname = font_arr[0]; }

            int fontproctemp = 0;

            try
            {

                fontproctemp = 1;
                float emSize = original.font.Size;
                if (font_arr.Length >= 2)
                {
                    if (font_arr[1] != "") { emSize = float.Parse(font_arr[1]); }
                }

                fontproctemp = 2;
                System.Drawing.FontStyle fontsty = original.font.Style;
                if (font_arr.Length >= 3)
                {
                    if (font_arr[2] != "") { fontsty = (System.Drawing.FontStyle)int.Parse(font_arr[2]); }
                }
                fontproctemp++;

#if !PocketPC

                fontproctemp = 3;
                System.Drawing.GraphicsUnit unit = original.font.Unit;
                if (font_arr.Length >= 4)
                {
                    if (font_arr[3] != "") { unit = (System.Drawing.GraphicsUnit)int.Parse(font_arr[3]); }
                }
#endif

                fontproctemp = 4;
                System.Drawing.StringAlignment halign = original.line_align;
                if (font_arr.Length >= 5)
                {
                    if (font_arr[4] != "") { halign = (System.Drawing.StringAlignment)int.Parse(font_arr[4]); }
                }

                fontproctemp = 5;
                double adjust_width = original.adjust_width;
                if (font_arr.Length >= 6)
                {
                    if (font_arr[5] != "") { adjust_width = double.Parse(font_arr[5]); }
                }

                return new WordFont(new System.Drawing.Font(fontname, emSize, fontsty
#if !PocketPC
                , unit
#endif
                ), halign, adjust_width);

            }
            catch
            {
                string[] t = new string[] { "BUG", "emSize", "style", "unit", "line_align", "adjust_width" };
                throw new JoyHackDataException("不正なフォント指定 (" + t[fontproctemp] + ") です: " + font_arr[fontproctemp]);
            }

        }
    }

    public struct WordCond
    {
        public ShowColor color;
        public int width;
        //public int ypos; //UNUSED
        public WordFont mainfont;
        public WordFont rubyfont;

        public void syncRubyFont()
        {
            this.rubyfont = new WordFont( new System.Drawing.Font
                (mainfont.font.Name , mainfont.font.Size / 2, mainfont.font.Style
#if !PocketPC
                , mainfont.font.Unit
#endif
                ), mainfont.line_align, mainfont.adjust_width);

        }

        public void reset()
        {
            this.width = -1;
        }
    }

    //<align>0
    public enum Alignment : byte
    {
        Default = 0,
        Left = 1,
        Center = 2,
        Right = 3,
    }

    //ハックデータの書式エラー
    public class JoyHackDataException : System.Exception
    {
        private bool _ignorable;
        public bool ignorable { get { return this._ignorable; } protected set { this._ignorable = value; } }

        public JoyHackDataException(string message) : this(message, false)
        {
        }

        public JoyHackDataException(string message, bool ignorable) : base(message) {
            this.ignorable = ignorable;
        }
    }



}