package jp.ac.u_ryukyu.ie.cr.bbs.local;


import jp.ac.u_ryukyu.ie.cr.jungle.DefaultJungle;
import jp.ac.u_ryukyu.ie.cr.jungle.Jungle;
import jp.ac.u_ryukyu.ie.cr.jungle.JungleTree;
import jp.ac.u_ryukyu.ie.cr.jungle.JungleTreeEditor;
import jp.ac.u_ryukyu.ie.cr.jungle.core.Children;
import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultTreeEditor;
import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser;
import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;

import java.nio.ByteBuffer;
import java.util.concurrent.atomic.AtomicInteger;

public class JungleBulletinBoard implements
		BulletinBoard {
	private final Jungle jungle;

	public JungleBulletinBoard() {
		jungle = new DefaultJungle(null, "hoge", new DefaultTreeEditor(
				new DefaultTraverser()));
		jungle.createNewTree("boards");
	}

	public Iterable<String> getBoards() {
		JungleTree tree = jungle.getTreeByName("boards");
		TreeNode node = tree.getRootNode();
		Children chs = node.getChildren();

		IterableConverter.Converter<String, TreeNode> converter = new IterableConverter.Converter<String, TreeNode>() {
			public String conv(TreeNode _b) {
				ByteBuffer e = _b.getAttributes().get("name");
				return new String(e.array());
			}
		};

		return new IterableConverter<String, TreeNode>(chs, converter);
	}

	public void createBoards(final String _name, final String _author,
			final String _initMessage, final String _editKey) {
		if (null == jungle.createNewTree(_name)) {
			throw new IllegalStateException();
		}
		JungleTree tree = jungle.getTreeByName("boards");
		JungleTreeEditor editor = tree.getTreeEditor();
		DefaultNodePath root = new DefaultNodePath();
		Either<Error, JungleTreeEditor> either = editor.addNewChildAt(root, 0);
		if (either.isA()) {
			throw new IllegalStateException();
		}
		editor = either.b();

		either = editor.putAttribute(root.add(0), "name", ByteBuffer.wrap(_name.getBytes()));
		if (either.isA()) {
			throw new IllegalStateException();
		}
		editor = either.b();
		Either<Error, JungleTreeEditor> result = editor.success();
		if (result.isA()) {
			throw new IllegalStateException();
		}

		tree = jungle.getTreeByName(_name);
		editor = tree.getTreeEditor();
		editor = editor.putAttribute(root,"author", ByteBuffer.wrap(_author.getBytes())).b();
		editor = editor.putAttribute(root,"key", ByteBuffer.wrap(_editKey.getBytes())).b();
		either = editor.putAttribute(root,"mes", ByteBuffer.wrap(_initMessage.getBytes()));

		if (either.isA()) {
			throw new IllegalStateException();
		}
		editor = either.b();
		editor.success();
	}

	public void createBoardMessage(final String _board, final String _author,
			final String _message, final String _editKey) {
		JungleTree tree = jungle.getTreeByName(_board);
		if (tree == null) {
			throw new IllegalStateException();
		}

		JungleTreeEditor editor;
		do {
			TreeNode node = tree.getRootNode();
			int size = node.getChildren().size();
			DefaultNodePath path = new DefaultNodePath();

			editor = tree.getTreeEditor();
			Either<Error, JungleTreeEditor> either = editor.addNewChildAt(path,
					size);
			if (either.isA()) {
				throw new IllegalStateException();
			}
			editor = either.b();
			editor = editor.putAttribute(path.add(size),"author", ByteBuffer.wrap(_author.getBytes())).b();
			editor = editor.putAttribute(path.add(size),"key", ByteBuffer.wrap(_editKey.getBytes())).b();
			either = editor.putAttribute(path.add(size),"mes", ByteBuffer.wrap(_message.getBytes()));

			if (either.isA()) {
				throw new IllegalStateException();
			}
			editor = either.b();
		}while (editor.success().isA());
	}

	public void editMessage(String _board, String _uuid, final String _author,
			final String _message, final String _editKey) {
		JungleTreeEditor editor = null;
		do {
			DefaultNodePath path = new DefaultNodePath();
			path = path.add(Integer.parseInt(_uuid));

			JungleTree tree = jungle.getTreeByName(_board);
			editor = tree.getTreeEditor();

			editor = editor.putAttribute(path,"author", ByteBuffer.wrap(_author.getBytes())).b();
			editor = editor.putAttribute(path,"key", ByteBuffer.wrap(_editKey.getBytes())).b();
			Either<Error, JungleTreeEditor> either = editor.putAttribute(path,"mes", ByteBuffer.wrap(_message.getBytes()));

			if (either.isA()) {
				throw new IllegalStateException();
			}
			editor = either.b();
		}while (editor.success().isA());
	}

	public Iterable<BoardMessage> getMessages(String _boardName) {
		JungleTree tree = jungle.getTreeByName(_boardName);
		TreeNode node = tree.getRootNode();
		Children chs = node.getChildren();

		final AtomicInteger counter = new AtomicInteger(0);
		IterableConverter.Converter<BoardMessage, TreeNode> converter = new IterableConverter.Converter<BoardMessage, TreeNode>() {
			public BoardMessage conv(TreeNode _b) {
				String uuid = Integer.toString(counter.get());
				String author = new String(_b.getAttributes().get("author").array());
				String message = new String(_b.getAttributes().get("mes").array());
				counter.incrementAndGet();
				return new BoardMessageImpl(author, message, uuid);
			}
		};

		return new IterableConverter<BoardMessage, TreeNode>(chs, converter);
	}

	private static class BoardMessageImpl implements BoardMessage {
		private final String author;
		private final String message;
		private final String uuid;

		public BoardMessageImpl(String _author, String _message, String _uuid) {
			author = _author;
			message = _message;
			uuid = _uuid;
		}

		public String getAuthor() {
			return author;
		}

		public String getMessage() {
			return message;
		}

		public String getUUID() {
			return uuid;
		}
	}

	public String sanitize(String str) {
		if (str == null) {
			return str;
		}
		str = str.replaceAll("&", "&amp;");
		str = str.replaceAll("<", "&lt;");
		str = str.replaceAll(">", "&gt;");
		str = str.replaceAll("\"", "&quot;");
		str = str.replaceAll("'", "&#39;");
		return str;
	}

    public GetAttributeImp getAttribute(String _bname, String nodePath,String revisionStr) {
        Long revision = Long.parseLong(revisionStr);
        DefaultNodePath path = createNodePath(nodePath);
        JungleTree tree = jungle.getTreeByName(_bname);
        JungleTree oldTree = tree.getOldTree(revision).b();
        Either<Error, TreeNode> either = tree.getNodeOfPath(path);
        if (either.isA())
            return new GetAttributeImp(new DefaultTreeNode());
        TreeNode node = either.b();
        return new GetAttributeImp(node);
    }

    private DefaultNodePath createNodePath(String nodePath) {
        DefaultNodePath path = new DefaultNodePath();
        try {
            for (int count = 0; nodePath.substring(count, count + 1) != null; count++) {
                if (!nodePath.substring(count, count + 1).equals("/"))
                    path = path.add(Integer.parseInt(nodePath.substring(count, count + 1)));
            }
        } catch (Exception _e) {
        }
        return path;
    }
}