/*
 * Copyright 2011 Future Systems, Inc
 * 
 * Licensed 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.krakenapps.pcap.decoder.netbios;

import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;

import org.krakenapps.pcap.decoder.tcp.TcpProcessor;
import org.krakenapps.pcap.decoder.tcp.TcpSessionKey;
import org.krakenapps.pcap.decoder.udp.UdpPacket;
import org.krakenapps.pcap.decoder.udp.UdpProcessor;
import org.krakenapps.pcap.util.Buffer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class NetBiosDecoder implements TcpProcessor, UdpProcessor {
	private final Logger logger = LoggerFactory.getLogger(NetBiosDecoder.class.getName());

	private NetBiosDatagramService datagramService;
	private NetBiosNameService nameService;
	private NetBiosSessionService sessionService;

	private Set<NetBiosNameProcessor> nameCallbacks = new CopyOnWriteArraySet<NetBiosNameProcessor>();
	private Set<NetBiosSessionProcessor> sessionCallbacks = new CopyOnWriteArraySet<NetBiosSessionProcessor>();
	private Set<NetBiosDatagramProcessor> datagramCallbacks = new CopyOnWriteArraySet<NetBiosDatagramProcessor>();

	public NetBiosDecoder() {
		datagramService = new NetBiosDatagramService();
		nameService = new NetBiosNameService();
		sessionService = new NetBiosSessionService();
	}

	public void registerNameProcessor(NetBiosNameProcessor callback) {
		nameCallbacks.add(callback);
	}

	public void unregisterNameProcessor(NetBiosNameProcessor callback) {
		nameCallbacks.remove(callback);
	}

	public void registerDatagramProcessor(NetBiosDatagramProcessor callback) {
		datagramCallbacks.add(callback);
	}

	public void unregisterDatagramProcessor(NetBiosDatagramProcessor callback) {
		datagramCallbacks.remove(callback);
	}

	public void registerSessionProcessor(NetBiosSessionProcessor callback) {
		sessionCallbacks.add(callback);
	}

	public void unregisterSessionProcessor(NetBiosSessionProcessor callback) {
		sessionCallbacks.remove(callback);
	}

	@Override
	public void handleRx(TcpSessionKey key, Buffer b) {
		NetBiosSessionPacket packet = sessionService.parseRx(b);

		if (NetBiosSessionType.isSessionMessage(packet)) {
			for (NetBiosSessionProcessor callback : sessionCallbacks) {
				callback.processRx(packet, key);
			}
		}
	}

	@Override
	public void handleTx(TcpSessionKey key, Buffer b) {
		NetBiosSessionPacket packet = sessionService.parseTx(b);

		if (NetBiosSessionType.isSessionMessage(packet)) {
			for (NetBiosSessionProcessor callback : sessionCallbacks) {
				callback.processTx(packet, key);
			}
		}
	}

	@Override
	public void onEstablish(TcpSessionKey key) {
	}

	@Override
	public void onFinish(TcpSessionKey key) {
	}

	@Override
	public void onReset(TcpSessionKey key) {
	}

	@Override
	public void process(UdpPacket p) {
		int port = p.getDestinationPort();

		Buffer b = p.getData();
		if (port == 137) {
			NetBiosNamePacket namePacket = nameService.parse(b);
			namePacket.setUdpPacket(p);

			for (NetBiosNameProcessor callback : nameCallbacks) {
				try {
					callback.process(namePacket);
				} catch (Exception e) {
					logger.warn("kraken netbios decoder: name processor should not throw any exception", e);
				}
			}
		} else if (port == 138) {
			NetBiosDatagramPacket datagramPacket = datagramService.parse(b);
			datagramPacket.setUdpPacket(p);
			switch (datagramPacket.getHeader().getMsgType()) {
			case DirectUniqueDatagram:
			case DirectGroupDatagram:
			case BroadcastDatagram: {
				for (NetBiosDatagramProcessor callback : datagramCallbacks) {
					callback.process(datagramPacket);
				}
			}
				break;
			default:
				return;
			}
		}
	}
}