/*
 * Copyright 2013-2014, Stephan Aßmus <superstippi@gmx.de>.
 * Copyright 2021, Andrew Lindesay <apl@lindesay.co.nz>.
 * All rights reserved. Distributed under the terms of the MIT License.
 */

#include "Paragraph.h"

#include <algorithm>
#include <stdio.h>


Paragraph::Paragraph()
	:
	fStyle()
{
}


Paragraph::Paragraph(const ParagraphStyle& style)
	:
	fStyle(style),
	fTextSpans(),
	fCachedLength(-1)
{
}


Paragraph::Paragraph(const Paragraph& other)
	:
	fStyle(other.fStyle),
	fTextSpans(other.fTextSpans),
	fCachedLength(other.fCachedLength)
{
}


Paragraph&
Paragraph::operator=(const Paragraph& other)
{
	fStyle = other.fStyle;
	fTextSpans = other.fTextSpans;
	fCachedLength = other.fCachedLength;

	return *this;
}


bool
Paragraph::operator==(const Paragraph& other) const
{
	if (this == &other)
		return true;

	return fStyle == other.fStyle
		&& fTextSpans == other.fTextSpans;
}


bool
Paragraph::operator!=(const Paragraph& other) const
{
	return !(*this == other);
}


int32
Paragraph::CountTextSpans() const
{
	return static_cast<int32>(fTextSpans.size());
}


const TextSpan&
Paragraph::TextSpanAtIndex(int32 index) const
{
	return fTextSpans[index];
}


void
Paragraph::SetStyle(const ParagraphStyle& style)
{
	fStyle = style;
}


bool
Paragraph::Prepend(const TextSpan& span)
{
	_InvalidateCachedLength();

	// Try to merge with first span if the TextStyles are equal
	if (!fTextSpans.empty()) {
		const TextSpan& firstSpan = fTextSpans[0];
		if (firstSpan.Style() == span.Style()) {
			BString text(span.Text());
			text.Append(firstSpan.Text());
			fTextSpans[0] = TextSpan(text, span.Style());
			return true;
		}
	}
	fTextSpans.push_back(span);
	return true;
}


bool
Paragraph::Append(const TextSpan& span)
{
	_InvalidateCachedLength();

	// Try to merge with last span if the TextStyles are equal
	if (!fTextSpans.empty()) {
		const TextSpan& lastSpan = fTextSpans[fTextSpans.size() - 1];
		if (lastSpan.Style() == span.Style()) {
			BString text(lastSpan.Text());
			text.Append(span.Text());
			fTextSpans.pop_back();
			fTextSpans.push_back(TextSpan(text, span.Style()));
			return true;
		}
	}
	fTextSpans.push_back(span);
	return true;
}


bool
Paragraph::Insert(int32 offset, const TextSpan& newSpan)
{
	_InvalidateCachedLength();

	int32 index = 0;

	{
		int32 countTextSpans = static_cast<int32>(fTextSpans.size());
		while (index < countTextSpans) {
			const TextSpan& span = fTextSpans[index];
			if (offset - span.CountChars() < 0)
				break;
			offset -= span.CountChars();
			index++;
		}

		if (countTextSpans == index)
			return Append(newSpan);
	}

	// Try to merge with span at index if the TextStyles are equal
	TextSpan span = fTextSpans[index];
	if (span.Style() == newSpan.Style()) {
		span.Insert(offset, newSpan.Text());
		fTextSpans[index] = span;
		return true;
	}

	if (offset == 0) {
		if (index > 0) {
			// Try to merge with TextSpan before if offset == 0 && index > 0
			TextSpan span = fTextSpans[index - 1];
			if (span.Style() == newSpan.Style()) {
				span.Insert(span.CountChars(), newSpan.Text());
				fTextSpans[index - 1] = span;
				return true;
			}
		}
		// Just insert the new span before the one at index
		fTextSpans.insert(fTextSpans.begin() + index, newSpan);
		return true;
	}

	// Split the span,
	TextSpan spanBefore = span.SubSpan(0, offset);
	TextSpan spanAfter = span.SubSpan(offset, span.CountChars() - offset);

	fTextSpans[index] = spanBefore;
	fTextSpans.insert(fTextSpans.begin() + (index + 1), newSpan);
	fTextSpans.insert(fTextSpans.begin() + (index + 2), spanAfter);
	return true;
}


bool
Paragraph::Remove(int32 offset, int32 length)
{
	if (length == 0)
		return true;

	_InvalidateCachedLength();

	int32 index = 0;

	{
		int32 countTextSpans = static_cast<int32>(fTextSpans.size());
		while (index < countTextSpans) {
			const TextSpan& span = fTextSpans[index];
			if (offset - span.CountChars() < 0)
				break;
			offset -= span.CountChars();
			index++;
		}

		if (index >= countTextSpans)
			return false;
	}

	TextSpan span(fTextSpans[index]);
	int32 removeLength = std::min(span.CountChars() - offset, length);
	span.Remove(offset, removeLength);
	length -= removeLength;
	index += 1;

	// Remove more spans if necessary
	while (length > 0 && index < static_cast<int32>(fTextSpans.size())) {
		int32 spanLength = fTextSpans[index].CountChars();
		if (spanLength <= length) {
			fTextSpans.erase(fTextSpans.begin() + index);
			length -= spanLength;
		} else {
			// Reached last span
			removeLength = std::min(length, spanLength);
			TextSpan lastSpan = fTextSpans[index].SubSpan(
				removeLength, spanLength - removeLength);
			// Try to merge with first span, otherwise replace span at index
			if (lastSpan.Style() == span.Style()) {
				span.Insert(span.CountChars(), lastSpan.Text());
				fTextSpans.erase(fTextSpans.begin() + index);
			} else {
				fTextSpans[index] = lastSpan;
			}

			break;
		}
	}

	// See if anything from the TextSpan at offset remained, keep it as empty
	// span if it is the last remaining span.
	index--;
	if (span.CountChars() > 0 || static_cast<int32>(fTextSpans.size()) == 1) {
		fTextSpans[index] = span;
	} else {
		fTextSpans.erase(fTextSpans.begin() + index);
		index--;
	}

	// See if spans can be merged after one has been removed.
	if (index >= 0 && index + 1 < static_cast<int32>(fTextSpans.size())) {
		const TextSpan& span1 = fTextSpans[index];
		const TextSpan& span2 = fTextSpans[index + 1];
		if (span1.Style() == span2.Style()) {
			span = span1;
			span.Append(span2.Text());
			fTextSpans[index] = span;
			fTextSpans.erase(fTextSpans.begin() + (index + 1));
		}
	}

	return true;
}


void
Paragraph::Clear()
{
	fTextSpans.clear();
}


int32
Paragraph::Length() const
{
	if (fCachedLength >= 0)
		return fCachedLength;

	int32 length = 0;
	std::vector<TextSpan>::const_iterator it;
	for (it = fTextSpans.begin(); it != fTextSpans.end(); it++) {
		const TextSpan& span = *it;
		length += span.CountChars();
	}

	fCachedLength = length;
	return length;
}


bool
Paragraph::IsEmpty() const
{
	return fTextSpans.empty();
}


bool
Paragraph::EndsWith(BString string) const
{
	int length = Length();
	int endLength = string.CountChars();
	int start = length - endLength;
	BString end = Text(start, endLength);
	return end == string;
}


BString
Paragraph::Text() const
{
	BString result;
	std::vector<TextSpan>::const_iterator it;
	for (it = fTextSpans.begin(); it != fTextSpans.end(); it++) {
		const TextSpan& span = *it;
		result << span.Text();
	}
	return result;
}


BString
Paragraph::Text(int32 start, int32 length) const
{
	Paragraph subParagraph = SubParagraph(start, length);
	return subParagraph.Text();
}


Paragraph
Paragraph::SubParagraph(int32 start, int32 length) const
{
	if (start < 0)
		start = 0;

	if (start == 0 && length == Length())
		return *this;

	Paragraph result(fStyle);

	std::vector<TextSpan>::const_iterator it;
	for (it = fTextSpans.begin(); it != fTextSpans.end(); it++) {
		const TextSpan& span = *it;
		int32 spanLength = span.CountChars();
		if (spanLength == 0)
			continue;
		if (start > spanLength) {
			// Skip span if its before start
			start -= spanLength;
			continue;
		}

		// Remaining span length after start
		spanLength -= start;
		int32 copyLength = std::min(spanLength, length);

		if (start == 0 && length == spanLength)
			result.Append(span);
		else
			result.Append(span.SubSpan(start, copyLength));

		length -= copyLength;
		if (length == 0)
			break;

		// Next span is copied from its beginning
		start = 0;
	}

	return result;
}


void
Paragraph::PrintToStream() const
{
	int32 spanCount = static_cast<int32>(fTextSpans.size());
	if (spanCount == 0) {
		printf("  <p/>\n");
		return;
	}
	printf("  <p>\n");
	for (int32 i = 0; i < spanCount; i++) {
		const TextSpan& span = fTextSpans[i];
		if (span.CountChars() == 0)
			printf("    <span/>\n");
		else {
			BString text = span.Text();
			text.ReplaceAll("\n", "\\n");
			printf("    <span>%s</span>\n", text.String());
		}
	}
	printf("  </p>\n");
}


// #pragma mark -


void
Paragraph::_InvalidateCachedLength()
{
	fCachedLength = -1;
}