/*
          @"<response>
          <version>0.1</version>
          <current_observation>
            <display_location>
              <city>Moscow</city>
            </display_location>
            <temp_c>-2</temp_c>
            <relative_humidity>93%</relative_humidity>
            <pressure_mb>1016</pressure_mb>
          </current_observation>
        </response>";
        */
        public override Weather Parse(string str)
        {
            try
            {
                var xdoc = XDocument.Parse(str);

                var ver = xdoc.XPathSelectValue("/response/version/text()");

                if (ver != "0.1")
                {
                    throw new FormatException("Version incompatibility (not equal 0.1)");
                }

                var weather = new Weather();

                var rootPrefix = "/response/current_observation";

                var tempStr = xdoc.XPathSelectValue(rootPrefix + "/temp_c/text()");
                weather.TemperatureC = float.Parse(tempStr);

                var humidityStr = xdoc.XPathSelectValue(rootPrefix + "/relative_humidity/text()");
                humidityStr = humidityStr.Replace("%", "");
                weather.HumidityPct = float.Parse(humidityStr) / 100;

                var presStr = xdoc.XPathSelectValue(rootPrefix + "/pressure_mb/text()");
                weather.PressureMB = float.Parse(presStr);

                return weather;
            }
            catch (Exception e)
            {
                throw new ParseException("Wunderground service response parse error", e);
            }
        }

        private static int CalcScore(IPlayerState state, Weather weather, int maxCard)
        {
            // winter -> drummer -> spring
            // winter makes everything worth 1
            // spring makes the global largest card worth +3

            // sum the normal cards & apply winter
            var score = state.Desk
                            .Where(card => !card.IsSpecial && card.HasValue)
                            .Sum(card => weather == Weather.Winter ? 1 : card.Value);

            if (IsDebugEnabled) log.Debug("Value card sum: " + score);

            // drummer
            if (state.Desk.FirstOrDefault(c => c.Kind == CardType.Drummer) != null)
            {
                score *= 2;

                if (IsDebugEnabled) log.Debug("With drummer: " + score);
            }

            // spring
            if (weather == Weather.Spring)
            {
                // apply spring
                var maxCardNum = state.Desk
                                    .Where(card => !card.IsSpecial && card.HasValue && card.Value == maxCard)
                                    .Count();

                score += maxCardNum * 3;

                if (IsDebugEnabled)
                {
                    log.Debug("Found {0} cards with maxValue {1}", maxCardNum, maxCard);
                    log.Debug("With spring: " + score);
                }
            }

            // special value cards (modifiers do not apply)
            score += state.Desk.Where(c => c.IsSpecial && c.HasValue).Sum(c => c.Value);

            if (IsDebugEnabled)
            {
                log.Debug("With specials: " + score);
                log.Debug("Scoring done.");
            }

            return score;
        }

    // Use this for initialization
    void Start () {

        waterZones = GameObject.FindGameObjectsWithTag("InteractableWater");

        currentWeather = Weather.CLEAR;
        day = true;

        skybox = RenderSettings.skybox;

        skybox.SetFloat("_DayToNight", 0f);
        skybox.SetFloat("_RainToSnow", 0f);
        skybox.SetFloat("_NormalToRainSnow", 0f);
        skybox.SetFloat("_RainSnowToSpecial", 0f);

        mainLight = FindObjectOfType<Light>();

        foreach (Material m in materials)
        {
            m.SetFloat("_Snow", 0f);
        }

        rain = GameObject.Find("PS_Rain");
        snow = GameObject.Find("PS_Snowflakes");
        other = GameObject.Find("PS_weather");

        rain.SetActive(false);
        snow.SetActive(false);
        other.SetActive(false);

        tM = FindObjectOfType<TrackManager>();

        SetAurore(false);
    }

        public Ball(Game game, Weather weather)
            : base(game)
        {
            //size = texture.Width;
            Size = 15;
            Shot = false;
            Pass = false;
            FreeKick = true;

            //set the initial position and acceleration
            Reset();

            //bound box rectangle
            Rectangle = new Rectangle((int)Position.X, (int)Position.Y, Size, Size);

            //current player who has the ball
            CurrentPlayer = null;

            switch (weather)
            {
                case Weather.sunny:
                    frictionFactor = 0.9f; break;

                case Weather.rainy:
                    frictionFactor = 2.0f; break;
            }
        }

        public List<Weather> getAllWithTags()
        {
            try
            {
                List<Weather> weathers = new List<Weather>();
                ISession session = cluster.Connect("maltmusic");

                String todo = ("select * from weathertags");
                PreparedStatement ps = session.Prepare(todo);
                BoundStatement bs = ps.Bind();
                // Execute Query
                RowSet rows = session.Execute(bs);
                foreach (Row row in rows)
                {
                    Guid tid = (Guid) row["track_id"];
                    List<String> theSet = (List<String>)row["tags"];
                    Weather toadd = new Weather(tid, theSet);
                    weathers.Add(toadd);
                }

                return weathers;
            }
            catch (Exception e)
            {
                Console.WriteLine("Broken returning weather tags " + e);
                return null;
            }
        }

 public WeatherReply(WeatherQuery query, Weather weather, DateTime replyTime, Exception exception = null)
 {
     Query = query;
     Weather = weather;
     ReplyTime = replyTime;
     Exception = exception;
 }

		public static void AddDynamicWeather( int temperature, int chanceOfPercipitation, int chanceOfExtremeTemperature, int moveSpeed, int width, int height, Rectangle2D bounds )
		{
			for ( int i = 0; i < m_Facets.Length; ++i )
			{
				Rectangle2D area = new Rectangle2D();
				bool isValid = false;

				for ( int j = 0; j < 10; ++j )
				{
					area = new Rectangle2D( bounds.X + Utility.Random( bounds.Width - width ), bounds.Y + Utility.Random( bounds.Height - height ), width, height );

					if ( !CheckWeatherConflict( m_Facets[i], null, area ) )
						isValid = true;

					if ( isValid )
						break;
				}

				if ( !isValid )
					continue;

				Weather w = new Weather( m_Facets[i], new Rectangle2D[]{ area }, temperature, chanceOfPercipitation, chanceOfExtremeTemperature, TimeSpan.FromSeconds( 30.0 ) );

				w.m_Bounds = bounds;
				w.m_MoveSpeed = moveSpeed;
			}
		}

        public override Weather Parse(string str)
        {
            try
            {
                var serializer = new XmlSerializer(typeof(OpenWeatherMapResponse));

                OpenWeatherMapResponse owmResponse;

                using (var strReader = new StringReader(str))
                {
                    owmResponse = (OpenWeatherMapResponse)serializer.Deserialize(strReader);
                }

                if (owmResponse.Humidity.unit != "%"
                    && owmResponse.Pressure.unit != "hPa"
                    && owmResponse.Temperature.unit != "metric")
                {
                    throw new FormatException("Value invalid unit");
                }

                var weather = new Weather()
                {
                    HumidityPct = owmResponse.Humidity.value / 100,
                    TemperatureC = owmResponse.Temperature.value,
                    PressureMB = owmResponse.Pressure.value,
                };

                return weather;

            }
            catch (Exception e)
            {
                throw new ParseException("OpenWeatherMap service response parse error", e);
            }
        }

        private readonly PokemonOutward[] pokemons; //onBoardOnly

        #endregion Fields

        #region Constructors

        /// <summary>
        /// 为了节约流量，只在用户第一次进入房间的时候给出teams/pms/weather信息
        /// </summary>
        internal Turn(TeamOutward[] teams, PokemonOutward[] pms, Weather weather)
        {
            Teams = teams;
              pokemons = pms;
              Weather = weather;
              Events = new List<GameEvent>();
        }

 public WeatherData(WeatherData data)
 {
     mType = data.mType;
     mTemp = data.mTemp;
     mLength = data.mLength;
     mWeight = data.mWeight;
 }

 public SettingsMenu(Weather weather, ScreenManager screenManager)
 {
     this.weather = weather;
     this.screenManager = screenManager;
     btnBack = new Button("Buttons", new Vector2(600, 400), new Rectangle(0, 120 * 6, 250, 120), false, false);
     btnChangeWeather = new Button("Buttons", new Vector2(200, 200), new Rectangle(250, 120 * 1, 250, 120), false, false);
     btnChangePlayer = new Button("Buttons", new Vector2(200, 400), new Rectangle(250, 120 * 0, 250, 120), false, false);
     LoadContent();
 }

 public WeatherMenu(ScreenManager screenManager, Weather weather)
 {
     this.screenManager = screenManager;
     this.weather = weather;
     btnBack = new Button("Buttons", new Vector2(600, 400), new Rectangle(0, 120 * 6, 250, 120), false, false);
     btnSunny = new Button("Buttons", new Vector2(200, 100), new Rectangle(250, 120 * 2, 250, 120), false, false);
     btnCloudy = new Button("Buttons", new Vector2(500, 100), new Rectangle(250, 120 * 3, 250, 120), false, false);
     btnRainy = new Button("Buttons", new Vector2(200, 300), new Rectangle(250, 120 * 4, 250, 120), false, false);
 }

        public static RandomEvent Create(int day, Weather weather)
        {
            if (weather == Weather.Cloudy)
                return CloudyEvent();

            if (weather == Weather.HotAndDry)
                return HotAndDryEvent();

            return SunnyEvent(day);
        }

 public bool CanGetForecast()
 {
     Weather weather = new Weather();
     string xmlData = weather.GetForecast(ZipCode);
     XmlDocument xmlDoc = new XmlDocument();
     xmlDoc.LoadXml(xmlData);
     XmlNode errorMessageNode = xmlDoc.SelectSingleNode("/errorMessage");
     bool hasError = (errorMessageNode != null);
     return !hasError;
 }

 public Board(GameSettings settings)
 {
     mode = settings.Mode;
       weather = Data.Weather.Normal;
       terrain = settings.Terrain;
       pokemons = new OnboardPokemon[settings.TeamCount, settings.XBound];
       Pokemons = new List<OnboardPokemon>();
       BoardConditions = new ConditionsDictionary();
       FieldConditions = new ConditionsDictionary[settings.TeamCount];
       for (int i = 0; i < settings.TeamCount; i++) FieldConditions[i] = new ConditionsDictionary();
 }

 public static void endOfTurn()
 {
     if (weather != Weather.normal)
     {
         weatherDur--;
         if (weatherDur <= 0)
         {
             weather = Weather.normal;
         }
     }
 }

 public Form1()
 {
     CL = new List<City>();
     var converter = new XmlSerializer(typeof(List<City>));
     var file = File.OpenText(".\\Cityes");
     CL = (List<City>)converter.Deserialize(file);
     file.Close();
     W = new Weather();
     button1 = new Button();
     InitializeComponent();
     Voice = new System.Speech.Synthesis.SpeechSynthesizer();
     this.Voice.SpeakCompleted += new System.EventHandler<System.Speech.Synthesis.SpeakCompletedEventArgs>(Comp);
 }

    public void SetWeather(Weather w)
    {
        currentWeather = w;
        secondsPassed = 0;

        if (weather)
            Destroy (weather);

        if (w == Weather.Sunny)
            Sunny ();
        else if (w == Weather.Rainy)
            Rainy ();
        else if (w == Weather.Cloudy)
            Cloudy ();
    }

        private string ParseResult(Weather weather)
        {
            if(weather.current_observation != null)
            {
                CurrentObservation o = weather.current_observation;
                DisplayLocation d = o.display_location;

                string result = string.Format("Weather for {0}{1}: {2}, {3}", d.full, (d.zip != null ? " (" + d.zip + ")" : ""), o.weather, o.temperature_string);
                result += string.Format("; feels like {0}. {1} winds. {2} humidity", o.feelslike_string, o.wind_string, o.relative_humidity);
                if(o.precip_today_metric != null)
                {
                    result += string.Format("; {0} precipitation today", o.precip_today_string);
                }
                return string.Format("{0}. {1}\n{2}", result, o.observation_time, o.forecast_url);
            }
            return null;
        }

        internal BoardOutward(GameSettings settings)
        {
            this.settings = settings;
              teams = new ObservableCollection<PokemonOutward>[settings.TeamCount];
              Teams = new ReadOnlyObservableCollection<PokemonOutward>[settings.TeamCount];
              pokemons = new List<PokemonOutward>();
              weather = Data.Weather.Normal;
              Terrain = settings.Terrain;

              var empty = new PokemonOutward[settings.XBound];
              for (int i = 0; i < settings.TeamCount; i++)
              {
            teams[i] = new ObservableCollection<PokemonOutward>(empty);
            Teams[i] = new ReadOnlyObservableCollection<PokemonOutward>(teams[i]);
              }

              listeners = new List<IBoardEvent>();
        }