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

#if PocketPC

#define CrazyDraw

#endif

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

using JoyHack;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.IO;

namespace JHDrawLib
{
    public class DrawJoyHack
    {
        private List<Phrase> lyr;
        private int _width, _height;
        private int _defaultFontSize;
        private int _timeCodeFix; //frames - set from datafile
        private int _timeUserFix; //frames - set from App
        private bool _strict;
        private bool _fadeinout = true; //TODO: FIXME

        private drawCache[] cache = new drawCache[4];

        public bool _debug;
        private string _warning;
        public bool disable_cache;

        public bool debug
        {
            get { return this._debug; }
            set {
                this.clear_cache();
                this._debug = value;
            }
        }

        public string warning
        {
            get { return this._warning; }
            private set { this._warning = value; }
        }

        public bool fadeinout
        {
            get { return this._fadeinout; }
            set {
                this.clear_cache();
                this._fadeinout = value;
            }
        }

        public int width
        {
            get { return this._width; }
            set
            {
                if (value <= 0) { throw new ArgumentOutOfRangeException(); }
                this.clear_cache();
                this._width = value;
            }
        }

        public int height
        {
            get { return this._height; }
            set
            {
                if (value <= 0) { throw new ArgumentOutOfRangeException(); }
                this.clear_cache();
                this._height = value;
            }
        }

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

        public int defaultFontSize
        {
            get { return this._defaultFontSize; }
            set
            {
                if (value < 1 || System.Single.MaxValue < value) { throw new ArgumentOutOfRangeException(); }
                this.clear_cache();
                this._defaultFontSize = value;
            }
        }

        public int timeCodeFix
        {
            get { return this._timeCodeFix; }
            private set { this._timeCodeFix = value; }
        }

        public int timeUserFix
        {
            get { return this._timeUserFix; }
            set { this._timeUserFix = value; }
        }

        public DrawJoyHack(Size size) : this(size.Width, size.Height)
        {
        }

        public DrawJoyHack(int width, int height)
        {
            this.lyr = new List<Phrase>();
            this.width = width;
            this.height = height;
            this.defaultFontSize = 30;
            this.timeCodeFix = 0;
            this.timeUserFix = 0;
            this.debug = false;
            this.disable_cache = false;
            this.strict = false;
            this.warning = null;
        }

        public void clear_cache ()
        {
            this.cache = new drawCache[4];
        }

        public void load_data(string file)
        {
            this.load_data(file, Encoding.GetEncoding(932));
        }

        public void load_data ( string file , Encoding encode )
        {

            lyr = new List<Phrase>();
            this.warning = null;
            this.clear_cache();

            FileStream fs = new FileStream(file, FileMode.Open);
            StreamReader sr = new StreamReader(fs, encode);

            int showline = 0; //index 0... (all_showline-1)
            int all_showline = 2; // 1...4

            string line;
            WordCond cond = new WordCond();

            cond.color = new ShowColor(
                new Color[8] {Color.White, Color.Black, Color.Red, Color.White,
                                        Color.White, Color.Black, Color.Red, Color.White}
                                        );

#if PocketPC
            cond.mainfont = new WordFont(
                new Font("MS Gothic", this.defaultFontSize, FontStyle.Regular), StringAlignment.Near, 1.0D);
            cond.rubyfont = new WordFont(
                new Font("MS Gothic", this.defaultFontSize / 2, FontStyle.Regular), StringAlignment.Near, 1.0D);
#else
            cond.mainfont = new WordFont(
                new Font("MS UI Gothic", this.defaultFontSize, FontStyle.Regular, GraphicsUnit.Pixel), StringAlignment.Near, 1.0D);
            cond.rubyfont = new WordFont(
                new Font("MS UI Gothic", this.defaultFontSize/2 , FontStyle.Regular, GraphicsUnit.Pixel), StringAlignment.Near, 1.0D);
#endif
  
            Alignment align = Alignment.Default;
            Timecode prevphr_endtime = new Timecode(0);

            float height = -1;
            int linenum = 0;

            while ((line = sr.ReadLine()) != null) {
                linenum++;

                try
                {

                    line = line.Replace("\r", "").Replace("\n", "");

                    if (line.IndexOf("<timeCodeFix>") >= 0 )
                    {
                        string timecodestr = line.Substring("<timeCodeFix>".Length);
                        if (timecodestr.Length == 0)
                        {
                            this.timeCodeFix = 0;
                        }
                        else if (timecodestr.Length == 8)
                        {
                            this.timeCodeFix = new Timecode(timecodestr).allFrames;
                        }
                        else if (timecodestr.Length == 9)
                        {
                            if (timecodestr.Substring(0, 1) == "-")
                            {
                                this.timeCodeFix = -(new Timecode(timecodestr.Substring(1, 8)).allFrames);
                            }
                            else
                            {
                                this.timeCodeFix = +(new Timecode(timecodestr.Substring(1, 8)).allFrames);
                            }
                        }
                        else
                        {
                            throw new JoyHackDataException("不正な<timeCodeFix>です: \"" + timecodestr + "\"");
                        }
                        continue;
                    }

                    if ( line.IndexOf("<x_align>") >= 0 )
                    {
                        string alignstr = line.Substring("<x_align>".Length);
                        byte align_i = byte.Parse(alignstr);
                        if (align_i < 0 || 3 < align_i) { throw new JoyHackDataException("不正な<x_align>です"); }
                        align = (Alignment)align_i;
                        continue;
                    }

                    if (line.IndexOf("<time>") >= 0)
                    {
                        Phrase p;
                        p = new Phrase(line, showline, all_showline, ref cond, align, prevphr_endtime, this.strict);
                        prevphr_endtime = p.getEndtime();
                        if (p.clear)
                        {
                            all_showline = p.all_showline;
                            showline = 0;
                            height = -1;
                        }
                        else
                        {
                            if (height < 0) { height = p.GetMaxHeight(); }
                            p.height = height;
                            showline = (++showline) % all_showline;
                        }
                        lyr.Add(p);

                    }
                }
                catch (JoyHackDataException e)
                {
                    if (!e.ignorable || this.strict)
                    {
                        fs.Close();
                        throw new JoyHackDataException(linenum.ToString() + " 行目: " + e.Message);
                    }
                }
                catch (Exception e)
                {
                    fs.Close();
                    throw new Exception( "[BUG] " + linenum.ToString() + " 行目: " + e.Message);
                }
            } //ReadLine while

            fs.Close();

            //Calc Appear/Disapp Time

            // Phraseが画面に収まるかチェック - 宣言
            List<Rectangle> arr_trash = new List<Rectangle>();
            Bitmap bmp_check = new Bitmap(this.width, this.height);
            Graphics g_check = Graphics.FromImage(bmp_check);
            g_check.SmoothingMode = SmoothingMode.AntiAlias;
            g_check.PixelOffsetMode = PixelOffsetMode.HighQuality;

            for (int i = 0; i < lyr.Count; i++)
            {
                //appear
                if (i == 0) { lyr[i].appearTime = new Timecode(0); }
                else
                {
                    if (lyr[i].all_showline == 1 || lyr[i - 1].clear)
                    {
                        lyr[i].appearTime = lyr[i - 1].getEndtime();
                    }
                    else
                    {
                        lyr[i].appearTime = lyr[i - 1].getStarttime();
                    }
                }

                //disappear
                if (i + 1 == lyr.Count) { lyr[i].disappTime = Timecode.getInfinity(); break; } //最終phr

                if (lyr[i].all_showline == 1) { lyr[i].disappTime = lyr[i].getEndtime(); }
                else
                {
                    for (int ni = 1; ni < lyr[i].all_showline; ni++)
                    {
                        if (i + ni >= lyr.Count) { break; } //OutOfRange
                        lyr[i].disappTime = lyr[i + ni].getStarttime();
                        if (lyr[i + ni].clear) { break; }
                    }
                }

#if DEBUG
                if (lyr[i].appearTime == null || lyr[i].disappTime == null)
                {
                    throw new NullReferenceException();
                }
#endif


                if (this.warning == null)
                {
                    // Phraseが画面に収まるかチェック
                    int all_width = this.getWordsWidth(ref arr_trash, lyr[i], g_check);
                    all_width += JHDrawConst.margin;
                    if (all_width > this.width)
                    {
                        this.warning = "[" + i + "] 画面に収まりきっていません";
                    }
                }
            }

        }

        public Timecode getFixedTimecode(Timecode time)
        {
            return new Timecode( System.Math.Max(0, time.allFrames - this.timeCodeFix - this.timeUserFix));
        }

        public int getDrawPhraseList(Timecode t, out List<DrawPhraseCond> drawphrlist)
        {

            drawphrlist = new List<DrawPhraseCond>();

            if (this.lyr.Count == 0) { return -1; }

            int i;
            for (i = this.lyr.Count; i >0; i--)
            {
                if (this.lyr[i-1].getStarttime() < t) { break; }
            }
            i = i - 1; //Now Playing or Last Played

            int l_showlines;
            Phrase[] drawTemp = { null, null, null, null };
            bool playing_i = false;

            if (i >= 0)
            {
                if (this.lyr[i].getEndtime() >= t)
                { // Now Playing
                    playing_i = true;
                    if (this.lyr[i].clear) { return i; }
                }
                l_showlines = this.lyr[i].all_showline;

                if (l_showlines >= 2 || playing_i)
                {
                    if (!this.lyr[i].clear) {
                        drawTemp[this.lyr[i].showline] = this.lyr[i];
                    }
                }

                if (l_showlines >= 3 && !this.lyr[i].clear)
                {
                    if (i - 1 >= 0)
                    {
                        if (!this.lyr[i - 1].clear)
                        {
                            drawTemp[this.lyr[i-1].showline] = this.lyr[i-1];
                            if (i - 2 >= 0 && l_showlines >= 4)
                            {
                                if (!this.lyr[i - 2].clear)
                                {
                                    drawTemp[this.lyr[i-2].showline] = this.lyr[i-2];
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                //if (i + 1 >= this.lyr.Count) { throw new Exception("空の歌詞データです"); }
                l_showlines = this.lyr[i + 1].all_showline;
            }

            if (i + 1 < this.lyr.Count)
            {
                if (!playing_i || l_showlines >= 2)
                {
                    if (!this.lyr[i + 1].clear) { drawTemp[this.lyr[i+1].showline] = this.lyr[i+1]; }
                }
            }

            for (int cnt = 0; cnt < l_showlines; cnt++)
            {
                if (drawTemp[cnt] != null)
                {
                    drawphrlist.Add(new DrawPhraseCond(drawTemp[cnt], (int)(this.height - drawTemp[cnt].GetTerritoryHeight() * (drawTemp[cnt].all_showline - cnt) - 10)));
                }
            }
            return i;
        }

        //public delegate void DrawPhraseProc(Phrase p, Timecode fixedTime, int y);

        // 戻り値:
        //     全長
        private int getWordsWidth(ref List<Rectangle> width_arr, Phrase phr, Graphics g)
        {
            int all_width = 0;

#if PocketPC
            Encoding sjisEnc = Encoding.GetEncoding("Shift_JIS");
            for (int i = 0; i < phr.words.Count; i++)
            {
                int wid = (int)(10 * 96 / 72) * sjisEnc.GetByteCount(phr.words[i].str);
                all_width += wid;
                width_arr.Add(new Rectangle(0, 0, wid, (int)(20 * 96 / 72)));
            }

#else
            StringFormat allsf = new StringFormat();
            allsf.FormatFlags = StringFormatFlags.NoClip | StringFormatFlags.NoWrap;
            allsf.Trimming = StringTrimming.None;

            for (int i = 0; i < phr.words.Count; i++)
            {
                if (phr.words[i].str.Length == 0)
                {
                    width_arr.Add(new Rectangle(0, 0, 0, 0));
                    all_width += 0;
                    continue;
                }

                allsf.SetMeasurableCharacterRanges(
                    new CharacterRange[] { new CharacterRange(0, phr.words[i].str.Length) });

                Region[] rrr = g.MeasureCharacterRanges
                    (phr.words[i].str.Replace(' ', '_').Replace('　' /*full-width space*/, '駄'),
                    phr.words[i].cond.mainfont.font, new RectangleF(0, 0, this.width, this.height), allsf);
                Rectangle rrrect = Rectangle.Truncate(rrr[0].GetBounds(g));

                rrrect.Width = (int)(rrrect.Width * phr.words[i].cond.mainfont.adjust_width);
                rrrect.Width += 2;

                if (phr.words[i].cond.width >= 0)
                {
                    rrrect.Width = phr.words[i].cond.width;
                }

                all_width += rrrect.Width;
                width_arr.Add(rrrect);
            }
#endif

            return all_width;

        }

#if CrazyDraw
        private void drawWord_base(Graphics g_base, Word w, Rectangle strrect, float maxheight, int x, int y)
        {

            g_base.DrawString(w.str, new Font("MS Gothic", 20, FontStyle.Regular),
                new SolidBrush(Color.Blue), x, y, new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.NoWrap));

            return;
        }

        private void drawWord_effe(Graphics g_effe, Word w, Rectangle strrect, float maxheight, int x, int y)
        {

            g_effe.DrawString(w.str, new Font("MS Gothic", 20, FontStyle.Regular),
                new SolidBrush(Color.White), x - 1, y - 1, new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.NoWrap));

            g_effe.DrawString(w.str, new Font("MS Gothic", 20, FontStyle.Regular),
                new SolidBrush(Color.White), x - 1, y + 1, new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.NoWrap));

            g_effe.DrawString(w.str, new Font("MS Gothic", 20, FontStyle.Regular),
                new SolidBrush(Color.White), x + 1, y - 1, new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.NoWrap));

            g_effe.DrawString(w.str, new Font("MS Gothic", 20, FontStyle.Regular),
                new SolidBrush(Color.White), x + 1, y + 1, new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.NoWrap));

            g_effe.DrawString(w.str, new Font("MS Gothic", 20, FontStyle.Regular),
                new SolidBrush(Color.Red), x, y, new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.NoWrap));

            return;
        }
#endif

        private void drawWord(Graphics g_base, Graphics g_effe, Word w, Rectangle strrect, float maxheight, int x, int y)
        {

#if PocketPC
            Graphics g_test = DrawJoyHack.getNotNull<Graphics>(g_base, g_effe);
            strrect.Offset(x, y);
            g_test.DrawRectangle(new Pen(Color.Yellow), strrect);

            x -= 4;

            if ( g_base != null )
            {
                this.drawWord_base( g_base, w, strrect, maxheight, x, y );
            }

            if ( g_effe != null )
            {
                this.drawWord_effe( g_effe, w, strrect, maxheight, x, y );
            }

            return;
#else

            if (g_base == null || g_effe == null)
            {
                throw new NullReferenceException();
            }

            Font fnt = w.cond.mainfont.font;
            StringFormat sf = new StringFormat();

            sf.FormatFlags = StringFormatFlags.NoClip | StringFormatFlags.NoWrap;
            sf.Trimming = StringTrimming.None;
            sf.LineAlignment = w.cond.mainfont.line_align;

            int xoffset = strrect.X;

            x -= strrect.X;

            strrect.Offset(x, y + (int)(w.GetBelongPhrase().GetRealHeight(maxheight) * 0.6f));
            int font_height = strrect.Height;
            strrect.Height = (int)w.GetBelongPhrase().GetRealHeight(strrect.Height);

            //Matrix
            Matrix mat = new Matrix();
            mat.Scale(1f, w.GetBelongPhrase().GetRealHeight(1f));

            if (this.debug)
            { g_base.DrawRectangle(new Pen(Color.Red, 1), strrect); }

            GraphicsPath path = new GraphicsPath();
            path.AddString(w.str, fnt.FontFamily, (int)fnt.Style, font_height,
                new Rectangle(x, 0, this.width - x, (int)strrect.Height), sf);

            path.Transform(mat);
            Matrix maintrsmat = new Matrix();
            maintrsmat.Translate(0, strrect.Y);
            path.Transform(maintrsmat);

            Pen p = new Pen(w.cond.color[1], 5);
            // RecENT の不具合？ - Tik (2007年04月10日 22時22分26秒)
            p.LineJoin = System.Drawing.Drawing2D.LineJoin.Round;

            g_base.DrawPath(p, path);
            g_base.FillPath(new SolidBrush(w.cond.color[0]), path);

            p.Color = w.cond.color[3];
            g_effe.DrawPath(p, path);
            g_effe.FillPath(new SolidBrush(w.cond.color[2]), path);

            if (!String.IsNullOrEmpty(w.ruby))
            {
                Font rubyfont = w.cond.rubyfont.font;

                StringFormat sfr = new StringFormat();
                sfr.FormatFlags = StringFormatFlags.NoClip | StringFormatFlags.NoWrap;
                sfr.Trimming = StringTrimming.None;

                sfr.SetMeasurableCharacterRanges(new CharacterRange[] { new CharacterRange(0, w.ruby.Length) });
                Region[] regiruby = g_base.MeasureCharacterRanges(w.ruby, rubyfont, new RectangleF(0, 0, this.width, this.height), sfr);
                Rectangle recruby = Rectangle.Truncate(regiruby[0].GetBounds(g_base));

                sfr.LineAlignment = w.cond.rubyfont.line_align;

                if (recruby.Height > 0)
                {
                    recruby.Width = (int)(recruby.Width * w.cond.rubyfont.adjust_width);

                    if (recruby.Width < strrect.Width) { sfr.Alignment = StringAlignment.Center; }
                    else { sfr.Alignment = StringAlignment.Near; }

                    if (this.debug)
                    { g_base.DrawRectangle(new Pen(Color.Blue, 1), new Rectangle(x + xoffset, y, strrect.Width, (int)(w.GetBelongPhrase().GetRealHeight(maxheight) * 0.6f))); }

                    GraphicsPath path_r = new GraphicsPath();
                    path_r.AddString(w.ruby, rubyfont.FontFamily, (int)rubyfont.Style,
                        recruby.Height, new Rectangle(x + xoffset, 0, strrect.Width, (int)(w.GetBelongPhrase().GetRealHeight(maxheight) * 0.6f)), sfr);

                    path_r.Transform(mat);
                    Matrix rubytrsmat = new Matrix();
                    rubytrsmat.Translate(0, y);
                    path_r.Transform(rubytrsmat);

                    Pen pr = new Pen(w.cond.color[5], 2);
                    pr.LineJoin = System.Drawing.Drawing2D.LineJoin.Round;

                    g_base.DrawPath(pr, path_r);
                    g_base.FillPath(new SolidBrush(w.cond.color[4]), path_r);

                    pr.Color = w.cond.color[7];
                    g_effe.DrawPath(pr, path_r);
                    g_effe.FillPath(new SolidBrush(w.cond.color[6]), path_r);
                }
            }
#endif
        }


        public void drawPhraseUsingCache(Graphics g_moto, DrawPhraseCond phrcond, Timecode time)
        {

            if (phrcond.phr == null) { return; }

#if PocketPC
            throw new NotImplementedException("drawPhraseUsingCache はPocketPCでは使用できません");
#else
            
            Phrase phr = phrcond.phr;
            int y = phrcond.y;

            const System.Drawing.Imaging.PixelFormat pixelfmt
#if PocketPC
             = System.Drawing.Imaging.PixelFormat.Format24bppRgb;
#else
             = System.Drawing.Imaging.PixelFormat.Format32bppArgb;
#endif

            int debug_ypos = 50 + 20 * phr.showline;

            if (phr.clear) { return; }

            if (this.cache[phr.showline].phr != phr || this.disable_cache) //not hit...
            {
                
                this.cache[phr.showline] = new drawCache(phr);

                int img_height = phr.GetDrawHeight(); 

                //base
                Bitmap bmp1 = new Bitmap(this.width, img_height, pixelfmt);
                Graphics g_base = Graphics.FromImage(bmp1);
                this.cache[phr.showline].bmp_base = bmp1;

                //effected
                Bitmap bmp2 = new Bitmap(this.width, img_height, pixelfmt);
                Graphics g_effe = Graphics.FromImage(bmp2);
                this.cache[phr.showline].bmp_effe = bmp2;

#if !PocketPC

                g_base.SmoothingMode = SmoothingMode.AntiAlias;
                g_base.PixelOffsetMode = PixelOffsetMode.HighQuality;

                g_effe.SmoothingMode = SmoothingMode.AntiAlias;
                g_effe.PixelOffsetMode = PixelOffsetMode.HighQuality;
#endif
                //List<int> drawedX = this.drawPhrase(g_base, g_effe, phrcond);
                List<int> drawedX = this.drawPhrase(g_base, g_effe, phr, 0);

                this.cache[phr.showline].drawed_X = drawedX;

            }
            else
            {
                if (this.debug)
                    g_moto.DrawString("HIT!" , new Font(FontFamily.GenericMonospace, 20, FontStyle.Regular),
                        new SolidBrush(Color.Salmon), 40, debug_ypos);
            }

            if (this.debug)
            {
                g_moto.DrawString( phr.showline.ToString() + ":", new Font(FontFamily.GenericMonospace, 20, FontStyle.Regular),
                        new SolidBrush(Color.HotPink), 10, debug_ypos);
            }

            if (phr.words.Count + 1 != this.cache[phr.showline].drawed_X.Count)
            {
                throw new Exception("ワード数とキャッシュの対応がおかしいです");
            }


            System.Drawing.Imaging.ColorMatrix colorm = new System.Drawing.Imaging.ColorMatrix();
            colorm.Matrix00 = 1;
            colorm.Matrix11 = 1;
            colorm.Matrix22 = 1;
            colorm.Matrix33 = 1;
            colorm.Matrix44 = 1;

            if (this.fadeinout)
            {
                if ((time.allFrames - phr.appearTime.allFrames) < 10 && time.allFrames < phr.getStarttime().allFrames )
                {
                    colorm.Matrix33 = (time.allFrames - phr.appearTime.allFrames)/10.0f;
                    if (this.debug)
                    {
                        g_moto.DrawString("APPEAR", new Font(FontFamily.GenericMonospace, 20, FontStyle.Regular),
                            new SolidBrush(Color.LightSkyBlue), 125, debug_ypos);
                    }
                }

                if ((phr.disappTime.allFrames - time.allFrames) < 10 && time.allFrames > phr.getEndtime().allFrames )
                {
                    colorm.Matrix33 = (phr.disappTime.allFrames - time.allFrames) / 10.0f;

                    if (this.debug)
                    {
                        g_moto.DrawString("DISAPP", new Font(FontFamily.GenericMonospace, 20, FontStyle.Regular),
                            new SolidBrush(Color.LightSkyBlue), 125, debug_ypos);
                    }
                }
            }

            System.Drawing.Imaging.ImageAttributes imageatt = new System.Drawing.Imaging.ImageAttributes();
            imageatt.SetColorMatrix(colorm);

            int afterx = this.getDrawPosX(phr, this.cache[phr.showline].drawed_X, time);
            System.Diagnostics.Stopwatch stw = new System.Diagnostics.Stopwatch();

            int drawy = phrcond.y;
            int drawh = phr.GetDrawHeight();
            
            stw.Start();

            if (this.width != afterx)
            {
                g_moto.DrawImage(this.cache[phr.showline].bmp_base, new Rectangle(afterx, drawy, this.width - afterx, drawh), afterx, 0, this.width - afterx, drawh, GraphicsUnit.Pixel, imageatt);
            }

            if (afterx != 0)
            {
                g_moto.DrawImage(this.cache[phr.showline].bmp_effe, new Rectangle(0, drawy, afterx, drawh), 0, 0, afterx, drawh, GraphicsUnit.Pixel, imageatt);
            }

            stw.Stop();

            if (this.debug)
            {
                g_moto.DrawString("Time:" + stw.ElapsedTicks, new Font(FontFamily.GenericMonospace, 20, FontStyle.Regular),
                    new SolidBrush(Color.OrangeRed), 250, 50 + 20 * phr.showline);
            }

            long etete = stw.ElapsedTicks;

#endif
        }

        public List<int> drawPhrase(Graphics g_base, Graphics g_effe, Phrase phr, int y)
        {
            DrawPhraseCond phrcond = new DrawPhraseCond(phr, y);
            return this.drawPhrase(g_base, g_effe, phrcond);
        }

        //Return: drawed_X
        public List<int> drawPhrase(Graphics g_base, Graphics g_effe, DrawPhraseCond phrcond)
        {
            if (phrcond.phr == null) { return null; }

            Graphics g_test = g_base;
            if (g_test == null) { g_test = g_effe; }
            if (g_test == null) { throw new NullReferenceException(); }

            Phrase phr = phrcond.phr;

            if (phr.clear)
            {
                throw new ArgumentException("<clear>フレーズは描画できません");
            }

            List<int> drawedX = new List<int>(); //Returner

            List<Rectangle> width_arr = new List<Rectangle>();
            int all_width = this.getWordsWidth(ref width_arr, phr, g_test);

            /*
             * For Debug...
            
            int xxxx = JHDrawConst.margin;
            foreach (Rectangle r in width_arr)
            {
                if (r.Width == 0) { continue; }
                r.Offset(xxxx, 0);
                g_base.DrawString(r.Width.ToString(), new Font(FontFamily.GenericMonospace, 10, FontStyle.Regular),
                    Brushes.Gold, xxxx+3, 5);
                xxxx += r.Width;
                g_base.DrawRectangle(Pens.Gold, r);
            }
            */


            int x = -1;
            Alignment align = phr.align;
            if (align == Alignment.Default)
            {
                if ((phr.all_showline % 2) == 0)
                {
                    if ((phr.showline % 2) == 0) { align = Alignment.Left; }
                    else
                    {
                        align = Alignment.Right;
                    }
                }
                else if (phr.all_showline == 3)
                {
                    if (phr.showline == 0) { align = Alignment.Left; }
                    else if (phr.showline == 1)
                    {
                        align = Alignment.Center;
                    }
                    else if (phr.showline == 2)
                    {
                        align = Alignment.Right;
                    }
                }
                else if (phr.all_showline == 1)
                {
                    align = Alignment.Left;
                }
            }

            switch (align)
            {
                case Alignment.Left:
                    x = JHDrawConst.margin;
                    break;
                case Alignment.Center:
                    x = Math.Max((this.width - all_width) / 2, JHDrawConst.margin);
                    break;
                case Alignment.Right:
                    x = Math.Max(this.width - JHDrawConst.margin - all_width, JHDrawConst.margin);
                    break;
                default:
                    throw new Exception("表示行がなんかおかしいです");
                //break;
            }

            for (int i = 0; i < phr.words.Count; i++)
            {
                Word w = phr.words[i];

                int lsi;
                int oldX = x;

                Rectangle strrect = width_arr[i];
                if (w.str.Length == 0 || strrect.Width <= 0)
                {
                    //goto skip_drawing;
                    lsi = 0;
                }
                else
                {
                    this.drawWord(g_base, g_effe, w, strrect, phr.GetMaxHeight(), x, phrcond.y);
                    lsi = strrect.Width;
                }

                drawedX.Add(oldX);
                x = oldX + lsi;
            } //word loop end

            drawedX.Add(x);

            return drawedX;
        }

        public int getDrawPosX(Phrase phr, List<int>drawed_X, Timecode time)
        {
            if (phr.clear)
            {
                throw new ArgumentException("<clear>フレーズは描画できません");
            }

            int afterx;

            if (phr.getEndtime() < time)
            {
                afterx = this.width; //^^;
            }
            else
            {
                afterx = 0;
                for (int wcnt = 0; wcnt < phr.words.Count; wcnt++)
                {
                    if (phr.words[wcnt].time < time && time < phr.getWordEnd(phr.words[wcnt]))
                    {
                        float allf = (float)(phr.getWordEnd(phr.words[wcnt]).allFrames - phr.words[wcnt].time.allFrames);
                        int nowf = time.allFrames - phr.words[wcnt].time.allFrames;
                        afterx = drawed_X[wcnt]
                            + (int)((drawed_X[wcnt + 1] - drawed_X[wcnt]) * (nowf / allf));
                        break;
                    }
                    else if (phr.getWordEnd(phr.words[wcnt]) <= time)
                    {
                        afterx = drawed_X[wcnt + 1];
                    }
                }
            }

            if (afterx < 0) { afterx = 0; }
            if (afterx > this.width) { afterx = this.width; }

            return afterx;
        }

    }

    public struct DrawPhraseCond
    {
        public Phrase phr;
        public int y;

        public DrawPhraseCond(Phrase phrase, int y)
        {
            this.phr = phrase;
            this.y = y;
        }
    }

    public struct drawCache
    {
        public Phrase phr;
        public Bitmap bmp_base;
        public Bitmap bmp_effe;
        public List<int> drawed_X;

        public drawCache(Phrase phrase)
        {
            this.phr = phrase;
            this.bmp_base = null;
            this.bmp_effe = null;
            this.drawed_X = new List<int>();
        }
    }

    public static class JHDrawConst
    {
        public const int margin = 20;
    }

}