/*****************************************************************************
 * encvtt.c: Encoder for WEBVTT as ISO1446-30 payload
 *****************************************************************************
 * Copyright (C) 2018 VideoLabs, VLC authors and VideoLAN
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 *****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include <vlc_common.h>
#include <vlc_plugin.h>
#include <vlc_codec.h>
#include <vlc_subpicture.h>
#include <vlc_boxes.h>
#include <vlc_charset.h>
#include "webvtt.h"

static block_t *Encode ( encoder_t *, subpicture_t * );

int webvtt_OpenEncoder( vlc_object_t *p_this )
{
    encoder_t *p_enc = (encoder_t *)p_this;

    if( p_enc->fmt_out.i_codec != VLC_CODEC_WEBVTT )
        return VLC_EGENERIC;


    static const struct vlc_encoder_operations ops =
        { .encode_sub = Encode };
    p_enc->ops = &ops;

    return VLC_SUCCESS;
}

static void bo_add_escaped( bo_t *box, size_t len, const char *psz )
{
    if( likely(strcspn(psz, "&<>") >= len) )
    {
        bo_add_mem( box, len, psz );
    }
    else
    {
        for( size_t i=0; i<len; i++ )
        {
            switch(*psz)
            {
            case '&':
                bo_add_mem( box, 6, "&" );
                break;
            case '<':
                bo_add_mem( box, 6, "<" );
                break;
            case '>': /* escapes forbidden --> sequence */
                bo_add_mem( box, 6, ">" );
                break;
            default:
                bo_add_8( box, *psz );
                break;
            }
            psz++;
        }
    }
}

static void WriteText( const char *psz, bo_t *box, char *c_last )
{
    /* We need to break any double newline sequence
     * in or over segments */
    while(*psz)
    {
        const char *p = strchr( psz, '\n' );
        if( p )
        {
            bo_add_escaped( box, p - psz, psz );
            if( (*c_last == '\n' || *c_last == '\0') && *psz == '\n' )
                bo_add_mem( box, 8, "
" ); /* Add space for empty line */
            bo_add_8( box, '\n' );
            *c_last = '\n';
            psz = p + 1;
        }
        else
        {
            size_t len = strlen(psz);
            bo_add_escaped( box, len, psz );
            *c_last = (len > 0) ? psz[len - 1] : '\0';
            break;
        }
    }
}

static block_t *Encode( encoder_t *p_enc, subpicture_t *p_spu )
{
    VLC_UNUSED( p_enc );

    if( p_spu == NULL )
        return NULL;

    bo_t box;
    if( !bo_init( &box, 8 ) )
        return NULL;

    const subpicture_region_t *p_region;
    vlc_spu_regions_foreach_const(p_region, &p_spu->regions)
    {
        if(!subpicture_region_IsText( p_region )||
            p_region->p_text == NULL ||
            p_region->p_text->psz_text == NULL )
            continue;

        size_t i_offset = bo_size( &box );

        bo_add_32be( &box, 0 );
        bo_add_fourcc( &box, "vttc" );

        /* Payload */

        bo_add_32be( &box, 0 );
        bo_add_fourcc( &box, "payl" );

        char prevchar = '\0';
        /* This should already be UTF-8 encoded, so not much effort... */
        for( const text_segment_t *p_segment = p_region->p_text;
             p_segment; p_segment = p_segment->p_next )
        {
            if( p_segment->psz_text == NULL )
                continue;

            if( p_segment->p_ruby )
            {
                bo_add_mem( &box, 6, "<ruby>" );
                for( const text_segment_ruby_t *p_ruby = p_segment->p_ruby;
                                                p_ruby; p_ruby = p_ruby->p_next )
                {
                    WriteText( p_ruby->psz_base, &box, &prevchar );
                    bo_add_mem( &box, 4, "<rt>" );
                    WriteText( p_ruby->psz_rt, &box, &prevchar );
                    bo_add_mem( &box, 5, "</rt>" );
                }
                bo_add_mem( &box, 7, "</ruby>" );
                continue;
            }

            const text_style_t *style = p_segment->style;
            if( style && style->i_features )
            {
                if( style->i_features & STYLE_HAS_FLAGS )
                {
                    if( style->i_style_flags & STYLE_BOLD )
                        bo_add_mem( &box, 3, "<b>" );
                    if( style->i_style_flags & STYLE_UNDERLINE )
                        bo_add_mem( &box, 3, "<u>" );
                    if( style->i_style_flags & STYLE_ITALIC )
                        bo_add_mem( &box, 3, "<i>" );
                }
            }

            WriteText( p_segment->psz_text, &box, &prevchar );

            if( style && style->i_features )
            {
                if( style->i_features & STYLE_HAS_FLAGS )
                {
                    if( style->i_style_flags & STYLE_BOLD )
                        bo_add_mem( &box, 4, "</b>" );
                    if( style->i_style_flags & STYLE_UNDERLINE )
                        bo_add_mem( &box, 4, "</u>" );
                    if( style->i_style_flags & STYLE_ITALIC )
                        bo_add_mem( &box, 4, "</i>" );
                }
            }
        }

        bo_set_32be( &box, i_offset + 8, bo_size( &box ) - i_offset - 8 );

        /* Settings */

        if( (p_region->text_flags & (SUBPICTURE_ALIGN_LEFT|SUBPICTURE_ALIGN_RIGHT)) ||
                (p_region->i_align & SUBPICTURE_ALIGN_TOP) )
        {
            size_t i_start = bo_size( &box );

            bo_add_32be( &box, 0 );
            bo_add_fourcc( &box, "sttg" );

            if( p_region->text_flags & SUBPICTURE_ALIGN_LEFT )
                bo_add_mem( &box, 10, "align:left" );
            else if( p_region->text_flags & SUBPICTURE_ALIGN_RIGHT )
                bo_add_mem( &box, 11, "align:right" );

            if( p_region->i_align & SUBPICTURE_ALIGN_TOP )
            {
                float offset = 100.0;
                if( p_spu->i_original_picture_height > 0 )
                    offset = offset * p_region->i_y / p_spu->i_original_picture_height;
                if( bo_size( &box ) != i_start + 8 )
                    bo_add_8( &box, ' ' );
                char *psz;
                int i_printed = vlc_asprintf_c( &psz, "line:%2.2f%%", offset );
                if( i_printed >= 0 )
                {
                    if( i_printed > 0 )
                        bo_add_mem( &box, i_printed, psz );
                    free( psz );
                }
            }
            bo_set_32be( &box, i_start, bo_size( &box ) - i_start );
        }


        bo_set_32be( &box, i_offset, bo_size( &box ) - i_offset );
    }

    if( bo_size( &box ) == 0 ) /* No cue */
    {
        bo_add_32be( &box, 8 );
        bo_add_fourcc( &box, "vtte" );
    }

    block_t *p_block = box.b;
    box.b = NULL;
    bo_deinit( &box );

    if( p_block )
    {
        p_block->i_pts = p_block->i_dts = p_spu->i_start;
        if( p_spu->i_stop != VLC_TICK_INVALID && p_spu->i_stop > p_spu->i_start )
            p_block->i_length = p_spu->i_stop - p_spu->i_start;
    }

    return p_block;
}