/*-
 * Copyright (c) 1999,2000
 *	Konstantin Chuguev.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by Konstantin Chuguev
 *	and its contributors.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	iconv (Charset Conversion Library) v1.0
 */

#define ICONV_INTERNAL
#include "iconv.h"

#include <stdlib.h>	/* free, malloc */
#include <string.h>	/* memset, memcmp, memcpy */

typedef struct {
	const char	*sequence;
	apr_size_t	length;
	int		prefix_type;
} iconv_ces_iso2022_shift;

enum { ICONV_PREFIX_STATE = 0, ICONV_PREFIX_LINE, ICONV_PREFIX_CHAR };

static const iconv_ces_iso2022_shift iso_shift[] = {
    { "\x0f",  1, ICONV_PREFIX_STATE },
    { "\x0e",  1, ICONV_PREFIX_LINE },
    { "\x1bN", 2, ICONV_PREFIX_CHAR },
    { "\x1bO", 2, ICONV_PREFIX_CHAR }
};

#define shift_num (sizeof(iso_shift) / sizeof(iconv_ces_iso2022_shift))
#define SHIFT_LEN (sizeof(int) * shift_num)
#define	CESTOSTATE(ces)		((iconv_ces_iso2022_state_t *)ces->data)
#define	MODTOCCS(mod)		((struct iconv_ccs_desc *)(mod)->im_desc->imd_data)

typedef struct iconv_ces_iso2022_state {
	int	*shift_tab;
	int	shift_index;
	ucs_t	previous_char;
	char	prefix[128];
	int	nccs;
	const int *org_shift_tab;
	const struct iconv_module *ccsmod[1];
} iconv_ces_iso2022_state_t;

API_DECLARE_NONSTD(apr_status_t)
apr_iconv_iso2022_open(struct iconv_ces *ces, apr_pool_t *ctx)
{
	const iconv_ces_iso2022_ccs_t *ccsattr;
	const struct iconv_ccs_desc *ccs;
	iconv_ces_iso2022_state_t *state;
	struct iconv_module *depmod;
	apr_size_t stsz, shiftsz;
	int i;

	shiftsz = SHIFT_LEN;
	stsz = sizeof(iconv_ces_iso2022_state_t) +
	    sizeof(struct iconv_module *) * (ces->mod->im_depcnt - 1);
	state = (iconv_ces_iso2022_state_t *)malloc(stsz + shiftsz);
	if (state == NULL)
		return APR_ENOMEM;
	memset(state, 0, stsz + shiftsz);
	ces->data = state;
	state->shift_tab = (int*)((char*)state + stsz);
	state->org_shift_tab = ces->desc->data;
	apr_iconv_iso2022_reset(ces);
	state->nccs = ces->mod->im_depcnt;
	depmod = ces->mod->im_deplist;
	for (i = ces->mod->im_depcnt; i; i--, depmod = depmod->im_next) {
		state->ccsmod[i - 1] = depmod;
		ccs = MODTOCCS(depmod);
		ccsattr = depmod->im_depdata;
		if (ccsattr->designatorlen)
			state->prefix[(int)ccsattr->designator[0]] = 1;
		if (ccsattr->shift >= 0)
			state->prefix[(int)(iso_shift[ccsattr->shift].sequence[0])] = 1;
	}
	return APR_SUCCESS;
}

API_DECLARE_NONSTD(int)
apr_iconv_iso2022_close(struct iconv_ces *ces)
{
	free(ces->data);
	return 0;
}

API_DECLARE_NONSTD(void)
apr_iconv_iso2022_reset(struct iconv_ces *ces)
{
	struct iconv_ces_iso2022_state *state = CESTOSTATE(ces);

	memcpy(state->shift_tab, ces->desc->data, SHIFT_LEN);
	state->shift_index = 0;
	state->previous_char = UCS_CHAR_NONE;
}

static void
update_shift_state(const struct iconv_ces *ces, ucs_t ch)
{
	struct iconv_ces_iso2022_state *iso_state = CESTOSTATE(ces);
	apr_size_t i;

	if (ch == '\n' && iso_state->previous_char == '\r') {
		for (i = 0; i < shift_num; i ++) {
			if (iso_shift[i].prefix_type != ICONV_PREFIX_STATE)
				iso_state->shift_tab[i] = iso_state->org_shift_tab[i];
		}
        }
	iso_state->previous_char = ch;
}

#define is_7_14bit(ccs) ((ccs)->nbits & 7)

static apr_ssize_t
cvt_ucs2iso(const struct iconv_ces *ces, ucs_t in,
	unsigned char **outbuf, apr_size_t *outbytesleft, int cs)
{
	struct iconv_ces_iso2022_state *iso_state = CESTOSTATE(ces);
	const struct iconv_ces_iso2022_ccs *ccsattr;
	const struct iconv_ccs_desc *ccs;
	ucs_t res;
	apr_size_t len = 0;
	int need_designator, need_shift;

	ccs = MODTOCCS(iso_state->ccsmod[cs]);
	res = (in == UCS_CHAR_NONE) ?
	    in : ICONV_CCS_CONVERT_FROM_UCS(ccs, in);
	if (in != UCS_CHAR_NONE) {
		if (iso_shift[cs].prefix_type == ICONV_PREFIX_CHAR &&
		    !is_7_14bit(ccs)) {
			if ((res & 0x8080) == 0)
				return -1;
		    res &= 0x7F7F;
		} else if (res & 0x8080)
			return -1; /* Invalid/missing character in the output charset */
	}
	ccsattr = iso_state->ccsmod[cs]->im_depdata;
	if ((need_shift = (ccsattr->shift != iso_state->shift_index)))
		len += iso_shift[ccsattr->shift].length;
	if ((need_designator = (cs != iso_state->shift_tab[ccsattr->shift])))
		len += ccsattr->designatorlen;
	if (in != UCS_CHAR_NONE)
		len += res & 0xFF00 ? 2 : 1;
	if (len > *outbytesleft)
		return 0;	/* No space in output buffer */
	if (need_designator && (len = ccsattr->designatorlen)) {
		memcpy(*outbuf, ccsattr->designator, len);
		(*outbuf) += len;
		(*outbytesleft) -= len;
		iso_state->shift_tab[ccsattr->shift] = cs;
	}
	if (need_shift && (len = iso_shift[ccsattr->shift].length)) {
		memcpy(*outbuf, iso_shift[ccsattr->shift].sequence, len);
		(*outbuf) += len;
		(*outbytesleft) -= len;
		if (iso_shift[ccsattr->shift].prefix_type != ICONV_PREFIX_CHAR)
			iso_state->shift_index = ccsattr->shift;
	}
	if (in == UCS_CHAR_NONE)
		return 1;
	if (res & 0xFF00) {
		*(unsigned char *)(*outbuf) ++ = res >> 8;
		(*outbytesleft)--;
	}
	*(unsigned char *)(*outbuf) ++ = res;
	(*outbytesleft) --;
	update_shift_state(ces, res);
	return 1;
}

API_DECLARE_NONSTD(apr_ssize_t)
apr_iconv_iso2022_convert_from_ucs(struct iconv_ces *ces,
	ucs_t in, unsigned char **outbuf, apr_size_t *outbytesleft)
{
	struct iconv_ces_iso2022_state *iso_state = CESTOSTATE(ces);
	apr_ssize_t res;
	int cs, i;

	if (in == UCS_CHAR_NONE)
		return cvt_ucs2iso(ces, in, outbuf, outbytesleft, 0);
	if (iconv_char32bit(in))
		return -1;
	cs = iso_state->shift_tab[iso_state->shift_index];
	if ((res = cvt_ucs2iso(ces, in, outbuf, outbytesleft, cs)) >= 0)
		return res;
	for (i = 0; i < iso_state->nccs; i++) {
		if (i == cs)
			continue;
		if ((res = cvt_ucs2iso(ces, in, outbuf, outbytesleft, i)) >= 0)
			return res;
	}
	(*outbuf) ++;
	(*outbytesleft) --;
	return -1;	/* No character in output charset */
}

static ucs_t
cvt_iso2ucs(const struct iconv_ccs_desc *ccs, const unsigned char **inbuf,
	apr_size_t *inbytesleft, int prefix_type)
{
	apr_size_t bytes = ccs->nbits > 8 ? 2 : 1;
	ucs_t ch = **inbuf;

	if (*inbytesleft < bytes)
		return UCS_CHAR_NONE;	/* Not enough bytes in the input buffer */
	if (bytes == 2)
		ch = (ch << 8) | *(++(*inbuf));
	(*inbuf)++;
	(*inbytesleft) -= bytes;
	if (ch & 0x8080)
		return UCS_CHAR_INVALID;
	if (prefix_type == ICONV_PREFIX_CHAR && !is_7_14bit(ccs))
		ch |= (bytes == 2) ? 0x8080 : 0x80;
	return ICONV_CCS_CONVERT_TO_UCS(ccs, ch);
}

API_DECLARE_NONSTD(ucs_t)
apr_iconv_iso2022_convert_to_ucs(struct iconv_ces *ces,
	const unsigned char **inbuf, apr_size_t *inbytesleft)
{
	struct iconv_ces_iso2022_state *iso_state = CESTOSTATE(ces);
	const struct iconv_ces_iso2022_ccs *ccsattr;
	ucs_t res;
	const unsigned char *ptr = *inbuf;
	unsigned char byte;
	apr_size_t len, left = *inbytesleft;
	int i;

	while (left) {
		byte = *ptr;
		if (byte & 0x80) {
			(*inbuf)++;
			(*inbytesleft) --;
			return UCS_CHAR_INVALID;
		}
		if (!iso_state->prefix[byte])
			break;
		for (i = 0; i < iso_state->nccs; i++) {
			ccsattr = iso_state->ccsmod[i]->im_depdata;
			len = ccsattr->designatorlen;
			if (len) {
				if (len + 1 > left)
					return UCS_CHAR_NONE;
				if (memcmp(ptr, ccsattr->designator, len) == 0) {
					iso_state->shift_tab[ccsattr->shift] = i;
					ptr += len;
					left -= len;
					break;
				}
			}
			len = iso_shift[ccsattr->shift].length;
			if (len) {
				if (len + 1 > left)
					return UCS_CHAR_NONE;
				if (memcmp(ptr,
				    iso_shift[ccsattr->shift].sequence, len) == 0) {
					if (iso_shift[ccsattr->shift].prefix_type != ICONV_PREFIX_CHAR)
						iso_state->shift_index = ccsattr->shift;
					ptr += len;
					left -= len;
					break;
				}
			}
		}
	}
	i = iso_state->shift_tab[iso_state->shift_index];
	if (i < 0) {
		(*inbuf) ++;
		(*inbytesleft) --;
		return UCS_CHAR_INVALID;
	}
	res = cvt_iso2ucs(MODTOCCS(iso_state->ccsmod[i]), &ptr, &left, iso_shift[i].prefix_type);
	if (res != UCS_CHAR_NONE) {
		*inbuf = (const char*)ptr;
		*inbytesleft = left;
		update_shift_state(ces, res);
	}
	return res;
}