SchoolsAPI

using Sabio.Web.Models.Requests;
using Sabio.Web.Models.Responses;
using Sabio.Web.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Web.Http;

namespace Sabio.Web.Controllers.Api
{
    [RoutePrefix("api/Schools")]
    public class SchoolsApiController : ApiController
    {
        private ISchoolService _schoolService;

        public SchoolsApiController(ISchoolService SchoolService)
        {
            _schoolService = SchoolService;
        }

        [Route("AddSchool"), HttpPost]
        public HttpResponseMessage InsertSchool(SchoolAddRequest model)
        {
            if (!ModelState.IsValid && model != null)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }

            int id = _schoolService.InsertSchool(model);

            ItemResponse<int> response = new ItemResponse<int>();
            response.Item = id;

            return Request.CreateResponse(HttpStatusCode.OK, response);
        }

        [Route("GetListings/{id:int}"), HttpGet]
        public HttpResponseMessage GetListingSchools(string id)
        {
            ItemsResponse<GetListingSchools> response = new ItemsResponse<GetListingSchools>();
            response.Items = _schoolService.GetListingSchools(id);
            return Request.CreateResponse(HttpStatusCode.OK, response);
        }

        [Route("Update/{id:int}"), HttpPut]
        public HttpResponseMessage UpdateSchool(FullSchoolRequest model)
        {
            if (!ModelState.IsValid && model != null)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }
            _schoolService.UpdateSchool(model);
            SuccessResponse response = new SuccessResponse();

            return Request.CreateResponse(HttpStatusCode.OK, response);
        }

        [Route("SearchSchools"), HttpGet]
        public HttpResponseMessage SchoolSearch([FromUri]FullSchoolRequest model)
        {
            if (!ModelState.IsValid)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }
            try
            {
                List<FullSchoolRequest> results = _schoolService.SchoolSearch(model);
                ItemsResponse<FullSchoolRequest> response = new ItemsResponse<FullSchoolRequest>();
                response.Items = results;
                return Request.CreateResponse(HttpStatusCode.OK, response);
            }
            catch (Exception ex)
            {
                var response = new ErrorResponse(ex.Message);
                return Request.CreateResponse(HttpStatusCode.InternalServerError, response);
            }

        }

        [Route("PutSchoolPolygon/{ncesId}"), HttpPut]
        public HttpResponseMessage PutPolygon(SchoolPolygonPutRequest model)
        {
            if (!ModelState.IsValid && model != null)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }
            _schoolService.PutSchoolPolygon(model);
            SuccessResponse response = new SuccessResponse();

            return Request.CreateResponse(HttpStatusCode.OK, response);
        }

        [Route, HttpGet]
        public HttpResponseMessage GetAllSchools()
        {
            if (!ModelState.IsValid)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }
            ItemsResponse<FullSchoolRequest> response = new ItemsResponse<FullSchoolRequest>();
            response.Items = _schoolService.GetAllSchools();
            return Request.CreateResponse(HttpStatusCode.OK, response);
        }


        [Route("AddDistrict"), HttpPost]
        public HttpResponseMessage InsertDistrict(DistrictAddRequest model)
        {
            if (!ModelState.IsValid && model != null)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }

            int id = _schoolService.InsertDistrict(model);

            ItemResponse<int> response = new ItemResponse<int>();
            response.Item = id;

            return Request.CreateResponse(HttpStatusCode.OK, response);
        }

        [Route("SearchDistricts"), HttpGet]
        public HttpResponseMessage DistrictSearch([FromUri]FullDistrictRequest model)
        {
            if (!ModelState.IsValid)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }
            try
            {
                List<FullDistrictRequest> results = _schoolService.DistrictSearch(model);
                ItemsResponse<FullDistrictRequest> response = new ItemsResponse<FullDistrictRequest>();
                response.Items = results;
                return Request.CreateResponse(HttpStatusCode.OK, response);
            }
            catch (Exception ex)
            {
                var response = new ErrorResponse(ex.Message);
                return Request.CreateResponse(HttpStatusCode.InternalServerError, response);
            }

        }

        [Route("PutDistrictPolygon/{ncesCode:int}"), HttpPut]
        public HttpResponseMessage PutPolygon(DistrictPolygonPutRequest model)
        {
            if (!ModelState.IsValid && model != null)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }
            _schoolService.PutDistrictPolygon(model);
            SuccessResponse response = new SuccessResponse();

            return Request.CreateResponse(HttpStatusCode.OK, response);
        }

        [Route("PutZipCode"), HttpPost]
        public HttpResponseMessage InsertZipCode(ZipCodePutRequest model)
        {
            if (!ModelState.IsValid && model != null)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }
            string input = model.Polygon;

            var sequence = new List<GeoCoordinate>();

            var endCall = new { };

            var Key = new Key();

            var multi = false;

            var list = input.Split(' ');
            var length = list.Length;

            var count = 0;
            foreach (var set in list)
            {
                var pair = set.Split(',');
                if (pair.Length > 3)
                {
                    var lonOne = pair[0];
                    var latOne = pair[1];

                    var bundle = pair[2].Split('<');

                    var latTwo = pair[3];

                    var Break = bundle[1].Split('>');

                    var lonTwo = Break[1];

                    Key.startCall = @"MULTIPOLYGON(((";
                    Key.endCall = @")))";

                    GeoCoordinate coordinate1 = new GeoCoordinate();
                    GeoCoordinate coordinate2 = new GeoCoordinate();

                    coordinate2.Longitude = "((" + lonTwo;
                    coordinate2.Latitude = latTwo;

                    coordinate1.Longitude = lonOne;
                    coordinate1.Latitude = latOne + "))";

                    sequence.Add(coordinate1);
                    sequence.Add(coordinate2);

                    multi = true;

                }
                else
                {
                    GeoCoordinate coordinate = new GeoCoordinate();

                    var lon = pair[0];
                    var lat = pair[1];

                    if (count == 0)
                    {
                        var split = lon.Split('\"');
                        coordinate.Longitude = split[0];
                    }
                    else
                    {
                        coordinate.Longitude = lon;
                    }


                    if (count == (length - 1))
                    {
                        var split = lat.Split('\"');
                        coordinate.Latitude = split[0];
                    }
                    else
                    {
                        coordinate.Latitude = lat;
                    }

                    sequence.Add(coordinate);
                }
                count++;
            }


            if (multi == true)
            {

            }
            else
            {
                Key.startCall = @"POLYGON((";
                Key.endCall = @"))";
            }

            var coordinates = new List<GeoCoordinate>();
            var countSecond = 0;
            var sb = new StringBuilder();

            foreach (var coordinate in sequence)
            {
                if (countSecond == 0)
                {
                    sb.Append(Key.startCall + coordinate.Longitude + " " + coordinate.Latitude);
                }
                else
                {
                    sb.Append("," + coordinate.Longitude + " " + coordinate.Latitude);
                }

                countSecond++;
            }

            sb.Append(Key.endCall);

            model.Polygon = sb.ToString();
            _schoolService.PutZipCode(model);
            SuccessResponse response = new SuccessResponse();

            return Request.CreateResponse(HttpStatusCode.OK, response);
        }

        [Route("GetZipCode/{zipCode}"), HttpGet]
        public HttpResponseMessage GetZipCode(string zipCode)
        {
            if (!ModelState.IsValid)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }
            ItemResponse<ZipCodeGetRequest> response = new ItemResponse<ZipCodeGetRequest>();
            response.Item = _schoolService.GetZipCode(zipCode);
            return Request.CreateResponse(HttpStatusCode.OK, response);
        }

        [Route("GetZipCodeSchools/{zipCode}"), HttpGet]
        public HttpResponseMessage GetZipCodeSchools(string ZipCode)
        {
            ItemsResponse<FullSchoolRequest> response = new ItemsResponse<FullSchoolRequest>();
            response.Items = _schoolService.GetZipCodeSchools(ZipCode);
            return Request.CreateResponse(HttpStatusCode.OK, response);
        }

        [Route("GetMapSchools"), HttpGet]
        public HttpResponseMessage GetPolygonSchools([FromUri] MapSchoolsRequest model)
        {
            if (!ModelState.IsValid && model != null)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
            }
            ItemsResponse<FullSchoolRequest> response = new ItemsResponse<FullSchoolRequest>();
            response.Items = _schoolService.GetPolygonSchools(model);
            return Request.CreateResponse(HttpStatusCode.OK, response);
        }

        [Route("GetZipCodeDistricts/{zipCode}"), HttpGet]
        public HttpResponseMessage GetZipCodeDistricts(string ZipCode)
        {
            List<FullDistrictRequest> results = _schoolService.GetZipCodeDistricts(ZipCode);
            ItemsResponse<FullDistrictRequest> response = new ItemsResponse<FullDistrictRequest>();
            response.Items = results;
            return Request.CreateResponse(HttpStatusCode.OK, response);
        }

    }

}