// This code is derived from jcifs smb client library <jcifs at samba dot org>
// Ported by J. Arturo <webmaster at komodosoft dot net>
//  
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
using System;
using System.IO;
using System.Linq;
using System.Net;
using SharpCifs.Netbios;
using SharpCifs.Util;
using SharpCifs.Util.Sharpen;
using Extensions = SharpCifs.Util.Sharpen.Extensions;

namespace SharpCifs
{
	/// <summary>
	/// <p>Under normal conditions it is not necessary to use
	/// this class to use jCIFS properly.
	/// </summary>
	/// <remarks>
	/// <p>Under normal conditions it is not necessary to use
	/// this class to use jCIFS properly. Name resolusion is
	/// handled internally to the <code>jcifs.smb</code> package.
	/// <p>
	/// This class is a wrapper for both
	/// <see cref="Jcifs.Netbios.NbtAddress">Jcifs.Netbios.NbtAddress</see>
	/// and
	/// <see cref="System.Net.IPAddress">System.Net.IPAddress</see>
	/// . The name resolution mechanisms
	/// used will systematically query all available configured resolution
	/// services including WINS, broadcasts, DNS, and LMHOSTS. See
	/// <a href="../../resolver.html">Setting Name Resolution Properties</a>
	/// and the <code>jcifs.resolveOrder</code> property. Changing
	/// jCIFS name resolution properties can greatly affect the behavior of
	/// the client and may be necessary for proper operation.
	/// <p>
	/// This class should be used in favor of <tt>InetAddress</tt> to resolve
	/// hostnames on LANs and WANs that support a mixture of NetBIOS/WINS and
	/// DNS resolvable hosts.
	/// </remarks>
	public class UniAddress
	{
		private const int ResolverWins = 0;

		private const int ResolverBcast = 1;

		private const int ResolverDns = 2;

		private const int ResolverLmhosts = 3;

		private static int[] _resolveOrder;

		private static IPAddress _baddr;

		private static LogStream _log = LogStream.GetInstance();

		static UniAddress()
		{
			string ro = Config.GetProperty("jcifs.resolveOrder");
			IPAddress nbns = NbtAddress.GetWinsAddress();
			try
			{
				_baddr = Config.GetInetAddress("jcifs.netbios.baddr", Extensions.GetAddressByName
					("255.255.255.255"));
			}
			catch (UnknownHostException)
			{
			}
			if (string.IsNullOrEmpty(ro))
			{
				if (nbns == null)
				{
					_resolveOrder = new int[3];
					_resolveOrder[0] = ResolverLmhosts;
					_resolveOrder[1] = ResolverDns;
					_resolveOrder[2] = ResolverBcast;
				}
				else
				{
					_resolveOrder = new int[4];
					_resolveOrder[0] = ResolverLmhosts;
					_resolveOrder[1] = ResolverWins;
					_resolveOrder[2] = ResolverDns;
					_resolveOrder[3] = ResolverBcast;
				}
			}
			else
			{
				int[] tmp = new int[4];
				StringTokenizer st = new StringTokenizer(ro, ",");
				int i = 0;
				while (st.HasMoreTokens())
				{
					string s = st.NextToken().Trim();
					if (Runtime.EqualsIgnoreCase(s, "LMHOSTS"))
					{
						tmp[i++] = ResolverLmhosts;
					}
					else
					{
						if (Runtime.EqualsIgnoreCase(s, "WINS"))
						{
							if (nbns == null)
							{
								if (_log.Level > 1)
								{
									_log.WriteLine("UniAddress resolveOrder specifies WINS however the " + "jcifs.netbios.wins property has not been set"
										);
								}
								continue;
							}
							tmp[i++] = ResolverWins;
						}
						else
						{
							if (Runtime.EqualsIgnoreCase(s, "BCAST"))
							{
								tmp[i++] = ResolverBcast;
							}
							else
							{
								if (Runtime.EqualsIgnoreCase(s, "DNS"))
								{
									tmp[i++] = ResolverDns;
								}
								else
								{
									if (_log.Level > 1)
									{
										_log.WriteLine("unknown resolver method: " + s);
									}
								}
							}
						}
					}
				}
				_resolveOrder = new int[i];
				Array.Copy(tmp, 0, _resolveOrder, 0, i);
			}
		}

		internal class Sem
		{
			internal Sem(int count)
			{
				this.Count = count;
			}

			internal int Count;
		}

		internal class QueryThread : Thread
		{
			internal Sem Sem;

			internal string Host;

			internal string Scope;

			internal int Type;

			internal NbtAddress[] Ans;

			internal IPAddress Svr;

			internal UnknownHostException Uhe;

			internal QueryThread(Sem sem, string host, int type, string scope, IPAddress
				 svr) : base("JCIFS-QueryThread: " + host)
			{
				this.Sem = sem;
				this.Host = host;
				this.Type = type;
				this.Scope = scope;
				this.Svr = svr;
			}

			public override void Run()
			{
				try
				{
				    //Ans = new [] { NbtAddress.GetByName(Host, Type, Scope, Svr) };
				    Ans = NbtAddress.GetAllByName(Host, Type, Scope, Svr);
				}
				catch (UnknownHostException uhe)
				{
					this.Uhe = uhe;
				}
				catch (Exception ex)
				{
					Uhe = new UnknownHostException(ex.Message);
				}
				finally
				{
					lock (Sem)
					{
						Sem.Count--;
						Runtime.Notify(Sem);
					}
				}
			}
		}

		/// <exception cref="UnknownHostException"></exception>
		internal static NbtAddress[] LookupServerOrWorkgroup(string name, IPAddress svr)
		{
			Sem sem = new Sem(2);
			int type = NbtAddress.IsWins(svr) ? unchecked(0x1b) : unchecked(0x1d);
			QueryThread q1X = new QueryThread(sem, name, type, null, svr
				);
			QueryThread q20 = new QueryThread(sem, name, unchecked(0x20), null, svr);
			q1X.SetDaemon(true);
			q20.SetDaemon(true);
			try
			{
				lock (sem)
				{
					q1X.Start();
					q20.Start();
					while (sem.Count > 0 && q1X.Ans == null && q20.Ans == null)
					{
						Runtime.Wait(sem);
					}
				}
			}
			catch (Exception)
			{
				throw new UnknownHostException(name);
			}
			if (q1X.Ans != null)
			{
				return q1X.Ans;
			}
		    if (q20.Ans != null)
		    {
		        return q20.Ans;
		    }
		    throw q1X.Uhe;
		}

		/// <summary>Determines the address of a host given it's host name.</summary>
		/// <remarks>
		/// Determines the address of a host given it's host name. The name can be a
		/// machine name like "jcifs.samba.org",  or an IP address like "192.168.1.15".
		/// </remarks>
		/// <param name="hostname">NetBIOS or DNS hostname to resolve</param>
		/// <exception cref="UnknownHostException">if there is an error resolving the name
		/// 	</exception>
		public static UniAddress GetByName(string hostname)
		{
			return GetByName(hostname, false);
		}

		internal static bool IsDotQuadIp(string hostname)
		{
			if (char.IsDigit(hostname[0]))
			{
				int i;
				int len;
				int dots;
				char[] data;
				i = dots = 0;
				len = hostname.Length;
				data = hostname.ToCharArray();
				while (i < len && char.IsDigit(data[i++]))
				{
					if (i == len && dots == 3)
					{
						// probably an IP address
						return true;
					}
					if (i < len && data[i] == '.')
					{
						dots++;
						i++;
					}
				}
			}
			return false;
		}

		internal static bool IsAllDigits(string hostname)
		{
			for (int i = 0; i < hostname.Length; i++)
			{
				if (char.IsDigit(hostname[i]) == false)
				{
					return false;
				}
			}
			return true;
		}

		/// <summary>Lookup <tt>hostname</tt> and return it's <tt>UniAddress</tt>.</summary>
		/// <remarks>
		/// Lookup <tt>hostname</tt> and return it's <tt>UniAddress</tt>. If the
		/// <tt>possibleNTDomainOrWorkgroup</tt> parameter is <tt>true</tt> an
		/// addtional name query will be performed to locate a master browser.
		/// </remarks>
		/// <exception cref="UnknownHostException"></exception>
		public static UniAddress GetByName(string hostname, bool possibleNtDomainOrWorkgroup
			)
		{
			UniAddress[] addrs = GetAllByName(hostname, possibleNtDomainOrWorkgroup
				);
			return addrs[0];
		}

		/// <exception cref="UnknownHostException"></exception>
		public static UniAddress[] GetAllByName(string hostname, bool possibleNtDomainOrWorkgroup
			)
		{
			object addr;
			int i;
			if (string.IsNullOrEmpty(hostname))
			{
				throw new UnknownHostException();
			}
			if (IsDotQuadIp(hostname))
			{
				UniAddress[] addrs = new UniAddress[1];
				addrs[0] = new UniAddress(NbtAddress.GetByName(hostname));
				return addrs;
			}
			for (i = 0; i < _resolveOrder.Length; i++)
			{
				try
				{
					switch (_resolveOrder[i])
					{
						case ResolverLmhosts:
						{
							if ((addr = Lmhosts.GetByName(hostname)) == null)
							{
								continue;
							}
							break;
						}

						case ResolverWins:
						{
							if (hostname == NbtAddress.MasterBrowserName || hostname.Length > 15)
							{
								// invalid netbios name
								continue;
							}
							if (possibleNtDomainOrWorkgroup)
							{
								addr = LookupServerOrWorkgroup(hostname, NbtAddress.GetWinsAddress());
							}
							else
							{
								addr = NbtAddress.GetByName(hostname, unchecked(0x20), null, NbtAddress.GetWinsAddress
									());
							}
							break;
						}

						case ResolverBcast:
						{
							if (hostname.Length > 15)
							{
								// invalid netbios name
								continue;
							}

						    try
						    {
                                if (possibleNtDomainOrWorkgroup)
                                {
                                    NbtAddress[] iaddrs = LookupServerOrWorkgroup(hostname, _baddr);

                                    UniAddress[] addrs = new UniAddress[iaddrs.Length];
                                    for (int ii = 0; ii < iaddrs.Length; ii++)
                                    {
                                        addrs[ii] = new UniAddress(iaddrs[ii]);
                                    }
                                    return addrs;

                                }
                                else
                                {
                                    addr = NbtAddress.GetByName(hostname, unchecked(0x20), null, _baddr);
                                }

						    }
						    catch (Exception ex)
						    {
						        if (i == _resolveOrder.Length - 1)
						        {
						            throw ex;
						        }
						        else
						        {
						            continue;
						        }
						    }
							break;
						}

						case ResolverDns:
						{
							if (IsAllDigits(hostname))
							{
								throw new UnknownHostException(hostname);
							}

                            IPAddress[] iaddrs = Extensions.GetAddressesByName(hostname);

                            if (iaddrs == null || iaddrs.Length == 0)
                            {
                                continue;
                            }

                            return iaddrs.Select(iaddr => new UniAddress(iaddr)).ToArray();                            
						}

						default:
						{
							// Success
							throw new UnknownHostException(hostname);
						}
					}
					UniAddress[] addrs1 = new UniAddress[1];
					addrs1[0] = new UniAddress(addr);
					return addrs1;
				}
				catch (IOException)
				{
				}
			}
			// Success
			// Failure
			throw new UnknownHostException(hostname);
		}

		internal object Addr;

		internal string CalledName;

		/// <summary>
		/// Create a <tt>UniAddress</tt> by wrapping an <tt>InetAddress</tt> or
		/// <tt>NbtAddress</tt>.
		/// </summary>
		/// <remarks>
		/// Create a <tt>UniAddress</tt> by wrapping an <tt>InetAddress</tt> or
		/// <tt>NbtAddress</tt>.
		/// </remarks>
		public UniAddress(object addr)
		{
			if (addr == null)
			{
				throw new ArgumentException();
			}
			this.Addr = addr;
		}

		/// <summary>Return the IP address of this address as a 32 bit integer.</summary>
		/// <remarks>Return the IP address of this address as a 32 bit integer.</remarks>
		public override int GetHashCode()
		{
			return Addr.GetHashCode();
		}

		/// <summary>Compare two addresses for equality.</summary>
		/// <remarks>
		/// Compare two addresses for equality. Two <tt>UniAddress</tt>s are equal
		/// if they are both <tt>UniAddress</tt>' and refer to the same IP address.
		/// </remarks>
		public override bool Equals(object obj)
		{
			return obj is UniAddress && Addr.Equals(((UniAddress)obj).Addr);
		}

		/// <summary>Guess first called name to try for session establishment.</summary>
		/// <remarks>
		/// Guess first called name to try for session establishment. This
		/// method is used exclusively by the <tt>jcifs.smb</tt> package.
		/// </remarks>
		public virtual string FirstCalledName()
		{
			if (Addr is NbtAddress)
			{
				return ((NbtAddress)Addr).FirstCalledName();
			}
		    CalledName = ((IPAddress) Addr).GetHostAddress();
		    if (IsDotQuadIp(CalledName))
		    {
		        CalledName = NbtAddress.SmbserverName;
		    }
		    else
		    {
		        int i = CalledName.IndexOf('.');
		        if (i > 1 && i < 15)
		        {
		            CalledName = Runtime.Substring(CalledName, 0, i).ToUpper();
		        }
		        else
		        {
		            if (CalledName.Length > 15)
		            {
		                CalledName = NbtAddress.SmbserverName;
		            }
		            else
		            {
		                CalledName = CalledName.ToUpper();
		            }
		        }
		    }
		    return CalledName;
		}

		/// <summary>Guess next called name to try for session establishment.</summary>
		/// <remarks>
		/// Guess next called name to try for session establishment. This
		/// method is used exclusively by the <tt>jcifs.smb</tt> package.
		/// </remarks>
		public virtual string NextCalledName()
		{
			if (Addr is NbtAddress)
			{
				return ((NbtAddress)Addr).NextCalledName();
			}
		    if (CalledName != NbtAddress.SmbserverName)
		    {
		        CalledName = NbtAddress.SmbserverName;
		        return CalledName;
		    }
		    return null;
		}

		/// <summary>Return the underlying <tt>NbtAddress</tt> or <tt>InetAddress</tt>.</summary>
		/// <remarks>Return the underlying <tt>NbtAddress</tt> or <tt>InetAddress</tt>.</remarks>
		public virtual object GetAddress()
		{
			return Addr;
		}

		/// <summary>Return the hostname of this address such as "MYCOMPUTER".</summary>
		/// <remarks>Return the hostname of this address such as "MYCOMPUTER".</remarks>
		public virtual string GetHostName()
		{
			if (Addr is NbtAddress)
			{
				return ((NbtAddress)Addr).GetHostName();
			}
		    return ((IPAddress) Addr).GetHostAddress();
		}

		/// <summary>Return the IP address as text such as "192.168.1.15".</summary>
		/// <remarks>Return the IP address as text such as "192.168.1.15".</remarks>
		public virtual string GetHostAddress()
		{
			if (Addr is NbtAddress)
			{
				return ((NbtAddress)Addr).GetHostAddress();
			}
			return ((IPAddress)Addr).GetHostAddress();
		}

	    public virtual IPAddress GetHostIpAddress()
	    {
	        return (IPAddress) Addr;
	    }

		/// <summary>
		/// Return the a text representation of this address such as
		/// <tt>MYCOMPUTER/192.168.1.15</tt>.
		/// </summary>
		/// <remarks>
		/// Return the a text representation of this address such as
		/// <tt>MYCOMPUTER/192.168.1.15</tt>.
		/// </remarks>
		public override string ToString()
		{
			return Addr.ToString();
		}
	}
}