/// <summary>
 ///
 /// </summary>
 /// <param name="lineList"></param>
 /// <param name="leftLoc"></param>
 /// <param name="rightLoc"></param>
 private void AddCurves(IEnumerable lineList, LocationType leftLoc, LocationType rightLoc)
 {
     for (IEnumerator i = lineList.GetEnumerator(); i.MoveNext(); )
     {
         AddCurve(i.Current as IList<Coordinate>, leftLoc, rightLoc);
     }
 }

 public GatheringLocation(string name, LocationType locationType, 
     ItemType gatheredItemType, ItemType requiredItemType)
     : base(name, locationType)
 {
     this.GatheredType = gatheredItemType;
     this.RequiredItem = requiredItemType;
 }

        public Location(string name, LocationType type=LocationType.TOWN)
        {
            Name = name;
            Type = type;

            entityTable.rdsCount = 3;
        }

        public StorageAccount(
                string serviceName,
                string description,
                string locationOrAffinityGroup,
                LocationType locationType,
                StorageAccountGeoReplication geoReplication)
            : this()
        {
            Contract.Requires(!string.IsNullOrWhiteSpace(serviceName));
            Contract.Requires(!string.IsNullOrWhiteSpace(description));
            Contract.Requires(!string.IsNullOrWhiteSpace(locationOrAffinityGroup));

            ServiceName = Label = serviceName;
            Description = description;
            if (locationType == LocationType.Region)
            {
                Location = locationOrAffinityGroup;
            }
            else
            {
                AffinityGroup = locationOrAffinityGroup;
            }
            GeoReplicationEnabled = geoReplication != StorageAccountGeoReplication.Disabled;
            SecondaryReadEnabled = geoReplication == StorageAccountGeoReplication.ReadAccessEnabled;
            ExtendedProperties = new Dictionary<string, string>();
            Endpoints = new List<Uri>();
            SecondaryEndpoints = new List<Uri>();
        }

		// get the default location, given type of location
		public static string DefaultLocation(LocationType locationType)
		{
			string directory;

			switch(locationType) 
			{
				case LocationType.UserLocal:
					// Example: @"C:\Documents and Settings\<user>\Local Settings\Application Data\NASA\NASA World Wind\1.3.3.11250"
					return Application.LocalUserAppDataPath;
				
				case LocationType.UserCommon:
					// Example: @"C:\Documents and Settings\All Users\Application Data\NASA\NASA World Wind\1.3.3.11250"
					return Application.CommonAppDataPath;
				
				case LocationType.Application:
					// Example: @"C:\Program Files\NASA\World Wind\"
					return Application.StartupPath;

				default:
					// fall through to regular (roaming) user
				case LocationType.User:   
					// Example: @"C:\Documents and Settings\<user>\Application Data\NASA\World Wind\1.3.3"
					directory = Log.DefaultSettingsDirectory();
					Directory.CreateDirectory(directory);
					return directory;
			}
		}

        public StorageAccount(
            string serviceName,
            string description,
            string locationOrAffinityGroup,
            LocationType locationType,
            StorageAccountType storageAccountType)
            : this()
        {
            Contract.Requires(!string.IsNullOrWhiteSpace(serviceName));
            Contract.Requires(!string.IsNullOrWhiteSpace(description));
            Contract.Requires(!string.IsNullOrWhiteSpace(locationOrAffinityGroup));

            ServiceName = Label = serviceName;
            Description = description;
            if (locationType == LocationType.Region)
            {
                Location = locationOrAffinityGroup;
            }
            else
            {
                AffinityGroup = locationOrAffinityGroup;
            }
            AccountType = storageAccountType.ToString();

            ExtendedProperties = new Dictionary<string, string>();
            Endpoints = new List<Uri>();
            SecondaryEndpoints = new List<Uri>();
        }

        internal ExpressionBreakpoint(DebuggerSession session, ThreadGroup group,
					       LocationType type, string expression)
            : base(EventType.Breakpoint, expression, group)
        {
            this.Session = session;
            this.LocationType = type;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="location"></param>
        /// <returns></returns>
        public static int DepthAtLocation(LocationType location)
        {
            if (location == LocationType.Exterior)
                return 0;

            return location == LocationType.Interior ? 1 : NULL;
        }

 /// <summary>
 /// Constructs a TopologyLocation specifying how points on, to the left of, and to the
 /// right of some GraphComponent relate to some Geometry. Possible values for the
 /// parameters are Location.Null, Location.Exterior, Location.Boundary,
 /// and Location.Interior.
 /// </summary>
 /// <param name="on"></param>
 /// <param name="left"></param>
 /// <param name="right"></param>
 public TopologyLocation(LocationType on, LocationType left, LocationType right)
 {
     Init(3);
     _location[(int)PositionType.On] = on;
     _location[(int)PositionType.Left] = left;
     _location[(int)PositionType.Right] = right;
 }

        public void returns_expected_result_when_argument_is_valid(string value, LocationType expectedResult)
        {
            var parser = BuildParser();

            var result = parser.ParseProperty(value);

            Assert.AreEqual(expectedResult, result);
        }

	private void fillEnemyTypes (LocationType locationType) {
		enemyTypes.Clear();
		foreach (EnemyType type in Enum.GetValues(typeof(EnemyType))) {
			if (type.getLocationType() == locationType) {
				enemyTypes.Add(type);
			}
		}
	}

	public static Sprite getBackgroundSprite (LocationType locationType) {
		switch (locationType) {
			case LocationType.ENCHANTED_FOREST: return enchantedForest;
			case LocationType.PLAINS: return plains;
			case LocationType.TWILIGHT_VALLEY: return twilightValley;
			default: Debug.Log("Unknown Location type"); return null;
		}
	}

 public Location(LocationType type, int id, int lat, int lon, string place, string name)
 {
     this.Type = type;
     this.Id = id;
     this.Lat = lat;
     this.Lon = lon;
     this.Place = place;
     this.Name = name;
 }

 public Location(string name, string type)
     : base(name)
 {
     foreach (var locType in (LocationType[])Enum.GetValues(typeof(LocationType)))
     {
         if (locType.ToString() == type)
         {
             this.LocationType = locType;
         }
     }
 }

		private static Geometry MakeGeometry(LocationType locationType, double locationLat, double locationLong, double swLat, double swLong, double neLat, double neLong)
		{
			return new Geometry()
			{
				LocationType = locationType
				,
				Location = new LatLng(locationLat, locationLong)
				,
				Viewport = new Viewport(
				  southWest: new LatLng(swLat, swLong)
				  , northEast: new LatLng(neLat, neLong)
					)
			};
		}

 public static int AddLocation(Guid organizationId, int deptID,
                                string name,
                                LocationType typeID)
 {
     Locations loc = new Locations(organizationId);
     loc.AddNew();
     loc.DId = deptID;
     loc.Name = name;
     loc.LocationTypeId = (int)typeID;
     loc.Inactive = false;
     loc.IsDefault = false;
     loc.Save();
     return loc.Id;
 }

		private void OKbutton_Click(object sender, EventArgs e)
		{
			_server = serverTextBox.Text;
			if (dbNameRadioButton.Checked)
			{
				_locationType = LocationType.Name;
				_location = dbNameTextBox.Text;
			}
			else if (dbPathRadioButton.Checked)
			{
				_locationType = LocationType.Path;
				_location = dbPathTextBox.Text;
			}
		}

 /// <summary>
 /// Converts the location value to a location symbol, for example, <c>EXTERIOR => 'e'</c>.
 /// </summary>
 /// <param name="locationValue"></param>
 /// <returns>Either 'e', 'b', 'i' or '-'.</returns>
 public static char ToLocationSymbol(LocationType locationValue)
 {
     switch (locationValue)
     {
         case LocationType.Exterior:
             return 'e';
         case LocationType.Boundary:
             return 'b';
         case LocationType.Interior:
             return 'i';
         case LocationType.Null:
             return '-';
     }
     throw new ArgumentException("Unknown location value: " + locationValue);
 }

        public Location(string name, string fylke)
        {
            switch (GetType().Name)
            {
                case ("City"):
                    m_type = LocationType.City;
                    break;
                case ("Region"):
                    m_type = LocationType.Region;
                    break;
                default:
                    m_type = LocationType.City;
                    break;
            }

            m_name = name;
            m_fylke = fylke;
        }

        public async Task GetExistingAdvertisementUsingHalSelfLink(LocationType locationType, string givenStatement)
        {
            const string advertisementId = "8e2fde50-bc5f-4a12-9cfb-812e50500184";

            OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
            var link = $"{AdvertisementLink}/{advertisementId}";
            var viewRenderedAdvertisementLink = $"{AdvertisementLink}/{advertisementId}/view";

            var builderInitializer = new AllFieldsInitializer(locationType);

            this.SetupPactForGettingExistingAdvertisement(givenStatement, link, oAuth2Token, builderInitializer, advertisementId, viewRenderedAdvertisementLink);

            AdvertisementResource result;

            using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
            {
                result = await client.GetAdvertisementAsync(new Uri(this.Fixture.AdPostingApiServiceBaseUri, link));
            }

            this.AssertRetrievedAdvertisementMatchesExpected(builderInitializer, advertisementId, result);
        }