// SPDX-License-Identifier: GPL-2.0
/*
 * Vidtv serves as a reference DVB driver and helps validate the existing APIs
 * in the media subsystem. It can also aid developers working on userspace
 * applications.
 *
 * This file contains the code for a 'channel' abstraction.
 *
 * When vidtv boots, it will create some hardcoded channels.
 * Their services will be concatenated to populate the SDT.
 * Their programs will be concatenated to populate the PAT
 * Their events will be concatenated to populate the EIT
 * For each program in the PAT, a PMT section will be created
 * The PMT section for a channel will be assigned its streams.
 * Every stream will have its corresponding encoder polled to produce TS packets
 * These packets may be interleaved by the mux and then delivered to the bridge
 *
 *
 * Copyright (C) 2020 Daniel W. S. Almeida
 */

#include <linux/dev_printk.h>
#include <linux/ratelimit.h>
#include <linux/slab.h>
#include <linux/types.h>

#include "vidtv_channel.h"
#include "vidtv_common.h"
#include "vidtv_encoder.h"
#include "vidtv_mux.h"
#include "vidtv_psi.h"
#include "vidtv_s302m.h"

static void vidtv_channel_encoder_destroy(struct vidtv_encoder *e)
{
        struct vidtv_encoder *tmp = NULL;
        struct vidtv_encoder *curr = e;

        while (curr) {
                /* forward the call to the derived type */
                tmp = curr;
                curr = curr->next;
                tmp->destroy(tmp);
        }
}

#define ENCODING_ISO8859_15 "\x0b"
#define TS_NIT_PID      0x10

/*
 * init an audio only channel with a s302m encoder
 */
struct vidtv_channel
*vidtv_channel_s302m_init(struct vidtv_channel *head, u16 transport_stream_id)
{
        const __be32 s302m_fid              = cpu_to_be32(VIDTV_S302M_FORMAT_IDENTIFIER);
        char *event_text = ENCODING_ISO8859_15 "Bagatelle No. 25 in A minor for solo piano, also known as F\xfcr Elise, composed by Ludwig van Beethoven";
        char *event_name = ENCODING_ISO8859_15 "Ludwig van Beethoven: F\xfcr Elise";
        struct vidtv_s302m_encoder_init_args encoder_args = {};
        char *iso_language_code = ENCODING_ISO8859_15 "eng";
        char *provider = ENCODING_ISO8859_15 "LinuxTV.org";
        char *name = ENCODING_ISO8859_15 "Beethoven";
        const u16 s302m_es_pid              = 0x111; /* packet id for the ES */
        const u16 s302m_program_pid         = 0x101; /* packet id for PMT*/
        const u16 s302m_service_id          = 0x880;
        const u16 s302m_program_num         = 0x880;
        const u16 s302m_beethoven_event_id  = 1;
        struct vidtv_channel *s302m;

        s302m = kzalloc(sizeof(*s302m), GFP_KERNEL);
        if (!s302m)
                return NULL;

        s302m->name = kstrdup(name, GFP_KERNEL);
        if (!s302m->name)
                goto free_s302m;

        s302m->service = vidtv_psi_sdt_service_init(NULL, s302m_service_id, false, true);
        if (!s302m->service)
                goto free_name;

        s302m->service->descriptor = (struct vidtv_psi_desc *)
                                     vidtv_psi_service_desc_init(NULL,
                                                                 DIGITAL_RADIO_SOUND_SERVICE,
                                                                 name,
                                                                 provider);
        if (!s302m->service->descriptor)
                goto free_service;

        s302m->transport_stream_id = transport_stream_id;

        s302m->program = vidtv_psi_pat_program_init(NULL,
                                                    s302m_service_id,
                                                    s302m_program_pid);
        if (!s302m->program)
                goto free_service;

        s302m->program_num = s302m_program_num;

        s302m->streams = vidtv_psi_pmt_stream_init(NULL,
                                                   STREAM_PRIVATE_DATA,
                                                   s302m_es_pid);
        if (!s302m->streams)
                goto free_program;

        s302m->streams->descriptor = (struct vidtv_psi_desc *)
                                     vidtv_psi_registration_desc_init(NULL,
                                                                      s302m_fid,
                                                                      NULL,
                                                                      0);
        if (!s302m->streams->descriptor)
                goto free_streams;

        encoder_args.es_pid = s302m_es_pid;

        s302m->encoders = vidtv_s302m_encoder_init(encoder_args);
        if (!s302m->encoders)
                goto free_streams;

        s302m->events = vidtv_psi_eit_event_init(NULL, s302m_beethoven_event_id);
        if (!s302m->events)
                goto free_encoders;
        s302m->events->descriptor = (struct vidtv_psi_desc *)
                                    vidtv_psi_short_event_desc_init(NULL,
                                                                    iso_language_code,
                                                                    event_name,
                                                                    event_text);
        if (!s302m->events->descriptor)
                goto free_events;

        if (head) {
                while (head->next)
                        head = head->next;

                head->next = s302m;
        }

        return s302m;

free_events:
        vidtv_psi_eit_event_destroy(s302m->events);
free_encoders:
        vidtv_s302m_encoder_destroy(s302m->encoders);
free_streams:
        vidtv_psi_pmt_stream_destroy(s302m->streams);
free_program:
        vidtv_psi_pat_program_destroy(s302m->program);
free_service:
        vidtv_psi_sdt_service_destroy(s302m->service);
free_name:
        kfree(s302m->name);
free_s302m:
        kfree(s302m);

        return NULL;
}

static struct vidtv_psi_table_eit_event
*vidtv_channel_eit_event_cat_into_new(struct vidtv_mux *m)
{
        /* Concatenate the events */
        const struct vidtv_channel *cur_chnl = m->channels;
        struct vidtv_psi_table_eit_event *curr = NULL;
        struct vidtv_psi_table_eit_event *head = NULL;
        struct vidtv_psi_table_eit_event *tail = NULL;
        struct vidtv_psi_desc *desc = NULL;
        u16 event_id;

        if (!cur_chnl)
                return NULL;

        while (cur_chnl) {
                curr = cur_chnl->events;

                if (!curr)
                        dev_warn_ratelimited(m->dev,
                                             "No events found for channel %s\n",
                                             cur_chnl->name);

                while (curr) {
                        event_id = be16_to_cpu(curr->event_id);
                        tail = vidtv_psi_eit_event_init(tail, event_id);
                        if (!tail) {
                                vidtv_psi_eit_event_destroy(head);
                                return NULL;
                        }

                        desc = vidtv_psi_desc_clone(curr->descriptor);
                        vidtv_psi_desc_assign(&tail->descriptor, desc);

                        if (!head)
                                head = tail;

                        curr = curr->next;
                }

                cur_chnl = cur_chnl->next;
        }

        return head;
}

static struct vidtv_psi_table_sdt_service
*vidtv_channel_sdt_serv_cat_into_new(struct vidtv_mux *m)
{
        /* Concatenate the services */
        const struct vidtv_channel *cur_chnl = m->channels;

        struct vidtv_psi_table_sdt_service *curr = NULL;
        struct vidtv_psi_table_sdt_service *head = NULL;
        struct vidtv_psi_table_sdt_service *tail = NULL;

        struct vidtv_psi_desc *desc = NULL;
        u16 service_id;

        if (!cur_chnl)
                return NULL;

        while (cur_chnl) {
                curr = cur_chnl->service;

                if (!curr)
                        dev_warn_ratelimited(m->dev,
                                             "No services found for channel %s\n",
                                             cur_chnl->name);

                while (curr) {
                        service_id = be16_to_cpu(curr->service_id);
                        tail = vidtv_psi_sdt_service_init(tail,
                                                          service_id,
                                                          curr->EIT_schedule,
                                                          curr->EIT_present_following);
                        if (!tail)
                                goto free;

                        desc = vidtv_psi_desc_clone(curr->descriptor);
                        if (!desc)
                                goto free_tail;
                        vidtv_psi_desc_assign(&tail->descriptor, desc);

                        if (!head)
                                head = tail;

                        curr = curr->next;
                }

                cur_chnl = cur_chnl->next;
        }

        return head;

free_tail:
        vidtv_psi_sdt_service_destroy(tail);
free:
        vidtv_psi_sdt_service_destroy(head);
        return NULL;
}

static struct vidtv_psi_table_pat_program*
vidtv_channel_pat_prog_cat_into_new(struct vidtv_mux *m)
{
        /* Concatenate the programs */
        const struct vidtv_channel *cur_chnl = m->channels;
        struct vidtv_psi_table_pat_program *curr = NULL;
        struct vidtv_psi_table_pat_program *head = NULL;
        struct vidtv_psi_table_pat_program *tail = NULL;
        u16 serv_id;
        u16 pid;

        if (!cur_chnl)
                return NULL;

        while (cur_chnl) {
                curr = cur_chnl->program;

                if (!curr)
                        dev_warn_ratelimited(m->dev,
                                             "No programs found for channel %s\n",
                                             cur_chnl->name);

                while (curr) {
                        serv_id = be16_to_cpu(curr->service_id);
                        pid = vidtv_psi_get_pat_program_pid(curr);
                        tail = vidtv_psi_pat_program_init(tail,
                                                          serv_id,
                                                          pid);
                        if (!tail) {
                                vidtv_psi_pat_program_destroy(head);
                                return NULL;
                        }

                        if (!head)
                                head = tail;

                        curr = curr->next;
                }

                cur_chnl = cur_chnl->next;
        }
        /* Add the NIT table */
        vidtv_psi_pat_program_init(tail, 0, TS_NIT_PID);

        return head;
}

/*
 * Match channels to their respective PMT sections, then assign the
 * streams
 */
static void
vidtv_channel_pmt_match_sections(struct vidtv_channel *channels,
                                 struct vidtv_psi_table_pmt **sections,
                                 u32 nsections)
{
        struct vidtv_psi_table_pmt *curr_section = NULL;
        struct vidtv_psi_table_pmt_stream *head = NULL;
        struct vidtv_psi_table_pmt_stream *tail = NULL;
        struct vidtv_psi_table_pmt_stream *s = NULL;
        struct vidtv_channel *cur_chnl = channels;
        struct vidtv_psi_desc *desc = NULL;
        u16 e_pid; /* elementary stream pid */
        u16 curr_id;
        u32 j;

        while (cur_chnl) {
                for (j = 0; j < nsections; ++j) {
                        curr_section = sections[j];

                        if (!curr_section)
                                continue;

                        curr_id = be16_to_cpu(curr_section->header.id);

                        /* we got a match */
                        if (curr_id == cur_chnl->program_num) {
                                s = cur_chnl->streams;

                                /* clone the streams for the PMT */
                                while (s) {
                                        e_pid = vidtv_psi_pmt_stream_get_elem_pid(s);
                                        tail = vidtv_psi_pmt_stream_init(tail,
                                                                         s->type,
                                                                         e_pid);

                                        if (!head)
                                                head = tail;

                                        desc = vidtv_psi_desc_clone(s->descriptor);
                                        vidtv_psi_desc_assign(&tail->descriptor,
                                                              desc);

                                        s = s->next;
                                }

                                vidtv_psi_pmt_stream_assign(curr_section, head);
                                break;
                        }
                }

                cur_chnl = cur_chnl->next;
        }
}

static void
vidtv_channel_destroy_service_list(struct vidtv_psi_desc_service_list_entry *e)
{
        struct vidtv_psi_desc_service_list_entry *tmp;

        while (e) {
                tmp = e;
                e = e->next;
                kfree(tmp);
        }
}

static struct vidtv_psi_desc_service_list_entry
*vidtv_channel_build_service_list(struct vidtv_psi_table_sdt_service *s)
{
        struct vidtv_psi_desc_service_list_entry *curr_e = NULL;
        struct vidtv_psi_desc_service_list_entry *head_e = NULL;
        struct vidtv_psi_desc_service_list_entry *prev_e = NULL;
        struct vidtv_psi_desc *desc = s->descriptor;
        struct vidtv_psi_desc_service *s_desc;

        while (s) {
                while (desc) {
                        if (s->descriptor->type != SERVICE_DESCRIPTOR)
                                goto next_desc;

                        s_desc = (struct vidtv_psi_desc_service *)desc;

                        curr_e = kzalloc(sizeof(*curr_e), GFP_KERNEL);
                        if (!curr_e) {
                                vidtv_channel_destroy_service_list(head_e);
                                return NULL;
                        }

                        curr_e->service_id = s->service_id;
                        curr_e->service_type = s_desc->service_type;

                        if (!head_e)
                                head_e = curr_e;
                        if (prev_e)
                                prev_e->next = curr_e;

                        prev_e = curr_e;

next_desc:
                        desc = desc->next;
                }
                s = s->next;
        }
        return head_e;
}

int vidtv_channel_si_init(struct vidtv_mux *m)
{
        struct vidtv_psi_desc_service_list_entry *service_list = NULL;
        struct vidtv_psi_table_pat_program *programs = NULL;
        struct vidtv_psi_table_sdt_service *services = NULL;
        struct vidtv_psi_table_eit_event *events = NULL;

        m->si.pat = vidtv_psi_pat_table_init(m->transport_stream_id);
        if (!m->si.pat)
                return -ENOMEM;

        m->si.sdt = vidtv_psi_sdt_table_init(m->network_id,
                                             m->transport_stream_id);
        if (!m->si.sdt)
                goto free_pat;

        programs = vidtv_channel_pat_prog_cat_into_new(m);
        if (!programs)
                goto free_sdt;
        services = vidtv_channel_sdt_serv_cat_into_new(m);
        if (!services)
                goto free_programs;

        events = vidtv_channel_eit_event_cat_into_new(m);
        if (!events)
                goto free_services;

        /* look for a service descriptor for every service */
        service_list = vidtv_channel_build_service_list(services);
        if (!service_list)
                goto free_events;

        /* use these descriptors to build the NIT */
        m->si.nit = vidtv_psi_nit_table_init(m->network_id,
                                             m->transport_stream_id,
                                             m->network_name,
                                             service_list);
        if (!m->si.nit)
                goto free_service_list;

        m->si.eit = vidtv_psi_eit_table_init(m->network_id,
                                             m->transport_stream_id,
                                             programs->service_id);
        if (!m->si.eit)
                goto free_nit;

        /* assemble all programs and assign to PAT */
        vidtv_psi_pat_program_assign(m->si.pat, programs);

        /* assemble all services and assign to SDT */
        vidtv_psi_sdt_service_assign(m->si.sdt, services);

        /* assemble all events and assign to EIT */
        vidtv_psi_eit_event_assign(m->si.eit, events);

        m->si.pmt_secs = vidtv_psi_pmt_create_sec_for_each_pat_entry(m->si.pat,
                                                                     m->pcr_pid);
        if (!m->si.pmt_secs)
                goto free_eit;

        vidtv_channel_pmt_match_sections(m->channels,
                                         m->si.pmt_secs,
                                         m->si.pat->num_pmt);

        vidtv_channel_destroy_service_list(service_list);

        return 0;

free_eit:
        vidtv_psi_eit_table_destroy(m->si.eit);
free_nit:
        vidtv_psi_nit_table_destroy(m->si.nit);
free_service_list:
        vidtv_channel_destroy_service_list(service_list);
free_events:
        vidtv_psi_eit_event_destroy(events);
free_services:
        vidtv_psi_sdt_service_destroy(services);
free_programs:
        vidtv_psi_pat_program_destroy(programs);
free_sdt:
        vidtv_psi_sdt_table_destroy(m->si.sdt);
free_pat:
        vidtv_psi_pat_table_destroy(m->si.pat);
        return 0;
}

void vidtv_channel_si_destroy(struct vidtv_mux *m)
{
        u32 i;

        for (i = 0; i < m->si.pat->num_pmt; ++i)
                vidtv_psi_pmt_table_destroy(m->si.pmt_secs[i]);

        vidtv_psi_pat_table_destroy(m->si.pat);

        kfree(m->si.pmt_secs);
        vidtv_psi_sdt_table_destroy(m->si.sdt);
        vidtv_psi_nit_table_destroy(m->si.nit);
        vidtv_psi_eit_table_destroy(m->si.eit);
}

int vidtv_channels_init(struct vidtv_mux *m)
{
        /* this is the place to add new 'channels' for vidtv */
        m->channels = vidtv_channel_s302m_init(NULL, m->transport_stream_id);

        if (!m->channels)
                return -ENOMEM;

        return 0;
}

void vidtv_channels_destroy(struct vidtv_mux *m)
{
        struct vidtv_channel *curr = m->channels;
        struct vidtv_channel *tmp = NULL;

        while (curr) {
                kfree(curr->name);
                vidtv_psi_sdt_service_destroy(curr->service);
                vidtv_psi_pat_program_destroy(curr->program);
                vidtv_psi_pmt_stream_destroy(curr->streams);
                vidtv_channel_encoder_destroy(curr->encoders);
                vidtv_psi_eit_event_destroy(curr->events);

                tmp = curr;
                curr = curr->next;
                kfree(tmp);
        }
}