/****************************************************************
 * Licensed to the Apache Software Foundation (ASF) under one   *
 * or more contributor license agreements.  See the NOTICE file *
 * distributed with this work for additional information        *
 * regarding copyright ownership.  The ASF licenses this file   *
 * to you under the Apache License, Version 2.0 (the            *
 * "License"); you may not use this file except in compliance   *
 * with the License.  You may obtain a copy of the License at   *
 *                                                              *
 *   http://www.apache.org/licenses/LICENSE-2.0                 *
 *                                                              *
 * Unless required by applicable law or agreed to in writing,   *
 * software distributed under the License is distributed on an  *
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
 * KIND, either express or implied.  See the License for the    *
 * specific language governing permissions and limitations      *
 * under the License.                                           *
 ****************************************************************/

package org.apache.james.mime4j.io;

import org.apache.james.mime4j.util.ByteArrayBuffer;
import org.apache.james.mime4j.util.ContentUtil;
import org.junit.Assert;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;

public class MimeBoundaryInputStreamTest {

    private static BufferedLineReaderInputStream create(final String s, int bufSize) {
        return new BufferedLineReaderInputStream(InputStreams.createAscii(s), bufSize);
    }

    private static BufferedLineReaderInputStream create(final byte[] b, int bufSize) {
        return new BufferedLineReaderInputStream(InputStreams.create(b), bufSize);
    }

    @Test
    public void testBasicReading() throws IOException {
        String text = "Line 1\r\nLine 2\r\n--boundary\r\n" +
                "Line 3\r\nLine 4\r\n--boundary--";

        BufferedLineReaderInputStream buffer = create(text, 4096);

        MimeBoundaryInputStream mime1 = new MimeBoundaryInputStream(buffer, "boundary");
        Assert.assertEquals("Line 1\r\nLine 2", read(mime1, 5));

        Assert.assertFalse(mime1.isLastPart());

        MimeBoundaryInputStream mime2 = new MimeBoundaryInputStream(buffer, "boundary");
        Assert.assertEquals("Line 3\r\nLine 4", read(mime2, 5));

        Assert.assertTrue(mime2.isLastPart());
    }

    @Test
    public void testLenientLineDelimiterReading() throws IOException {
        String text = "Line 1\r\nLine 2\n--boundary\n" +
                "Line 3\r\nLine 4\n--boundary--\n";

        BufferedLineReaderInputStream buffer = create(text, 4096);

        MimeBoundaryInputStream mime1 = new MimeBoundaryInputStream(buffer, "boundary");
        Assert.assertEquals("Line 1\r\nLine 2", read(mime1, 5));

        Assert.assertFalse(mime1.isLastPart());

        MimeBoundaryInputStream mime2 = new MimeBoundaryInputStream(buffer, "boundary");
        Assert.assertEquals("Line 3\r\nLine 4", read(mime2, 5));

        Assert.assertTrue(mime2.isLastPart());
    }

    @Test
    public void testBasicReadingSmallBuffer1() throws IOException {
        String text = "yadayadayadayadayadayadayadayadayadayadayadayadayadayadayadayada\r\n--boundary\r\n" +
                "blahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblah\r\n--boundary--";

        BufferedLineReaderInputStream buffer = create(text, 20);

        MimeBoundaryInputStream mime1 = new MimeBoundaryInputStream(buffer, "boundary");
        Assert.assertEquals("yadayadayadayadayadayadayadayadayadayadayadayadayadayadayadayada",
                read(mime1, 10));

        Assert.assertFalse(mime1.isLastPart());

        MimeBoundaryInputStream mime2 = new MimeBoundaryInputStream(buffer, "boundary");
        Assert.assertEquals("blahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblah",
                read(mime2, 10));

        Assert.assertTrue(mime2.isLastPart());
    }

    @Test
    public void testBasicReadingSmallBuffer2() throws IOException {
        String text = "yadayadayadayadayadayadayadayadayadayadayadayadayadayadayadayada\r\n--boundary\r\n" +
                "blahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblah\r\n--boundary--";

        BufferedLineReaderInputStream buffer = create(text, 20);

        MimeBoundaryInputStream mime1 = new MimeBoundaryInputStream(buffer, "boundary");

        Assert.assertEquals("yadayadayadayadayadayadayadayadayadayadayadayadayadayadayadayada",
                read(mime1, 25));

        Assert.assertFalse(mime1.isLastPart());

        MimeBoundaryInputStream mime2 = new MimeBoundaryInputStream(buffer, "boundary");
        Assert.assertEquals("blahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblahblah",
                read(mime2, 25));

        Assert.assertTrue(mime2.isLastPart());
    }

    @Test
    public void testBasicReadingByOneByte() throws IOException {
        String text = "Line 1\r\nLine 2\r\n--boundary\r\n" +
                "Line 3\r\nLine 4\r\n--boundary--";

        BufferedLineReaderInputStream buffer = create(text, 4096);

        MimeBoundaryInputStream mime1 = new MimeBoundaryInputStream(buffer, "boundary");
        Assert.assertEquals("Line 1\r\nLine 2", readByOneByte(mime1));

        Assert.assertFalse(mime1.isLastPart());

        MimeBoundaryInputStream mime2 = new MimeBoundaryInputStream(buffer, "boundary");
        Assert.assertEquals("Line 3\r\nLine 4", readByOneByte(mime2));

        Assert.assertTrue(mime2.isLastPart());
    }

    /**
     * Tests that a CRLF immediately preceding a boundary isn't included in
     * the stream.
     */
    @Test
    public void testCRLFPrecedingBoundary() throws IOException {
        String text = "Line 1\r\nLine 2\r\n--boundary\r\n" +
                "Line 3\r\nLine 4\r\n\r\n--boundary\r\n";

        BufferedLineReaderInputStream buffer = create(text, 4096);

        MimeBoundaryInputStream mime1 = new MimeBoundaryInputStream(buffer, "boundary");
        Assert.assertEquals("Line 1\r\nLine 2", read(mime1, 5));

        Assert.assertFalse(mime1.isLastPart());

        MimeBoundaryInputStream mime2 = new MimeBoundaryInputStream(buffer, "boundary");
        Assert.assertEquals("Line 3\r\nLine 4\r\n", read(mime2, 5));

        Assert.assertFalse(mime2.isLastPart());
    }

    private String readByOneByte(InputStream is) throws IOException {
        StringBuilder sb = new StringBuilder();
        int b;
        while ((b = is.read()) != -1) {
            sb.append((char) b);
        }
        return sb.toString();
    }

    private String read(InputStream is, int bufsize) throws IOException {
        StringBuilder sb = new StringBuilder();
        int l;
        byte[] tmp = new byte[bufsize];
        while ((l = is.read(tmp)) != -1) {
            for (int i = 0; i < l; i++) {
                sb.append((char) tmp[i]);
            }
        }
        return sb.toString();
    }

    /**
     * Tests that a stream containing only a boundary is empty.
     */
    @Test
    public void testImmediateBoundary() throws IOException {
        String text1 = "--boundary\r\n";

        BufferedLineReaderInputStream buffer1 = create(text1, 4096);
        MimeBoundaryInputStream stream1 = new MimeBoundaryInputStream(buffer1, "boundary");
        Assert.assertEquals(-1, stream1.read());

        stream1.close();

        String text2 = "\r\n--boundary\r\n";

        BufferedLineReaderInputStream buffer2 = create(text2, 4096);
        MimeBoundaryInputStream stream2 = new MimeBoundaryInputStream(buffer2, "boundary");
        Assert.assertEquals(-1, stream2.read());

        stream2.close();
    }

    /**
     * Tests that hasMoreParts behave as expected.
     */
    @Test
    public void testHasMoreParts() throws IOException {
        String text = "--boundary--\r\n";

        BufferedLineReaderInputStream buffer = create(text, 4096);
        MimeBoundaryInputStream stream = new MimeBoundaryInputStream(buffer, "boundary");
        Assert.assertEquals(-1, stream.read());
        Assert.assertTrue(stream.isLastPart());

        stream.close();
    }

    /**
     * Tests that a stream containing only a boundary is empty.
     */
    @Test
    public void testPrefixIsBoundary() throws IOException {
        String text1 = "Line 1\r\n\r\n--boundary\r\n";

        BufferedLineReaderInputStream buffer1 = create(text1, 4096);
        MimeBoundaryInputStream stream1 = new MimeBoundaryInputStream(buffer1, "boundary");
        Assert.assertEquals("Line 1\r\n", read(stream1, 100));

        stream1.close();

        String text2 = "--boundary\r\n";

        BufferedLineReaderInputStream buffer2 = create(text2, 4096);
        MimeBoundaryInputStream stream2 = new MimeBoundaryInputStream(buffer2, "boundary");
        Assert.assertEquals(-1, stream2.read());

        stream2.close();
    }


    @Test
    public void testBasicReadLine() throws Exception {

        String[] teststrs = new String[5];
        teststrs[0] = "Hello\r\n";
        teststrs[1] = "This string should be much longer than the size of the input buffer " +
                "which is only 20 bytes for this test\r\n";
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 15; i++) {
            sb.append("123456789 ");
        }
        sb.append("and stuff like that\r\n");
        teststrs[2] = sb.toString();
        teststrs[3] = "\r\n";
        teststrs[4] = "And goodbye\r\n";

        String term = "\r\n--1234\r\n";

        ByteArrayBuffer buf = new ByteArrayBuffer(128);

        for (String teststr : teststrs) {
            byte[] b = ContentUtil.toAsciiByteArray(teststr);
            buf.append(b, 0, b.length);
        }
        byte[] tb = ContentUtil.toAsciiByteArray(term);
        buf.append(tb, 0, tb.length);
        byte[] raw = buf.toByteArray();

        BufferedLineReaderInputStream inbuffer = create(raw, 20);
        LineReaderInputStream instream = new MimeBoundaryInputStream(inbuffer, "1234");

        ByteArrayBuffer linebuf = new ByteArrayBuffer(8);
        for (String teststr : teststrs) {
            linebuf.clear();
            instream.readLine(linebuf);
            String s = ContentUtil.toAsciiString(linebuf);
            Assert.assertEquals(teststr, s);
        }
        Assert.assertEquals(-1, instream.readLine(linebuf));
        Assert.assertEquals(-1, instream.readLine(linebuf));

        instream.close();
    }

    @Test
    public void testReadEmptyLine() throws Exception {

        String teststr = "01234567890123456789\n\n\r\n\r\r\n\n\n\n\n\n--1234\r\n";
        byte[] raw = ContentUtil.toAsciiByteArray(teststr);

        BufferedLineReaderInputStream inbuffer = create(raw, 20);
        LineReaderInputStream instream = new MimeBoundaryInputStream(inbuffer, "1234");

        ByteArrayBuffer linebuf = new ByteArrayBuffer(8);
        linebuf.clear();
        instream.readLine(linebuf);
        String s = ContentUtil.toAsciiString(linebuf);
        Assert.assertEquals("01234567890123456789\n", s);

        linebuf.clear();
        instream.readLine(linebuf);
        s = ContentUtil.toAsciiString(linebuf);
        Assert.assertEquals("\n", s);

        linebuf.clear();
        instream.readLine(linebuf);
        s = ContentUtil.toAsciiString(linebuf);
        Assert.assertEquals("\r\n", s);

        linebuf.clear();
        instream.readLine(linebuf);
        s = ContentUtil.toAsciiString(linebuf);
        Assert.assertEquals("\r\r\n", s);

        linebuf.clear();
        instream.readLine(linebuf);
        s = ContentUtil.toAsciiString(linebuf);
        Assert.assertEquals("\n", s);

        linebuf.clear();
        instream.readLine(linebuf);
        s = ContentUtil.toAsciiString(linebuf);
        Assert.assertEquals("\n", s);

        linebuf.clear();
        instream.readLine(linebuf);
        s = ContentUtil.toAsciiString(linebuf);
        Assert.assertEquals("\n", s);

        linebuf.clear();
        instream.readLine(linebuf);
        s = ContentUtil.toAsciiString(linebuf);
        Assert.assertEquals("\n", s);

        Assert.assertEquals(-1, instream.readLine(linebuf));
        Assert.assertEquals(-1, instream.readLine(linebuf));

        instream.close();
    }

}