package io.everytrade.server.api.endpoint;

import io.everytrade.model.Portfolio;
import io.everytrade.model.PortfolioBalance;
import io.everytrade.model.PortfolioBalanceValue;
import io.everytrade.model.PortfolioHistory;
import io.everytrade.model.PortfolioResultValue;
import io.everytrade.model.RawTransaction;
import io.everytrade.server.api.endpoint.dto.PortfolioBalanceDTO;
import io.everytrade.server.api.endpoint.dto.PortfolioHistoryDTO;
import io.everytrade.server.api.endpoint.dto.PortfolioOpenDTO;
import io.everytrade.server.api.endpoint.dto.PortfolioSoldDTO;
import io.everytrade.server.auth.ResourceBase;

import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.time.Instant;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;


@Path("/")
public class BalancesEndpoint extends ResourceBase {
	@Context
	private HttpServletRequest request;

	@GET
	@Path("portfolio/{id}/balances/")
	@Consumes(MediaType.APPLICATION_JSON)
	@Produces(MediaType.APPLICATION_JSON)
	public Response post(@PathParam("id") long portfolioId, @QueryParam("type") String type, @QueryParam("timestamp") Long timestamp) {
		/*if(type == null){
			return error("Missing type for balances request.");
		}*/

		Portfolio portfolio = jpa.selectByID(Portfolio.class,portfolioId);
		if(portfolio == null){
			return error("Portfolio "+portfolioId+" not found");
		}
		if(portfolio.getOrganization().getId()!=getUser().getPerson().getOrganization().getId()){
			System.out.println("portfolio "+portfolio.getOrganization().getId()+"/"+getUser().getPerson().getOrganization().getId());
			return error(401);
		}


		Date d;
		if(timestamp == null){
			d = new Date();
		}else{
			d = new Date(timestamp);
		}

		PortfolioHistory history = jpa.selectFirstHistoryBeforeWithPortfolio(d, portfolio);

		if(history == null){
			return ok(new ArrayList<>());//error("No history for "+d+" and portfolio: "+portfolioId);
		}
		if(type == null){
			List<PortfolioBalanceDTO> result = new ArrayList<>();
			for (PortfolioBalance balance : jpa.selectPortfolioBalance(history)) {
				List<PortfolioBalanceValue> portfolioBalanceValues = jpa.selectBalanceValuesByBalance(balance);
				List<PortfolioResultValue> portfolioResultValues = jpa.selectResultValuesByBalance(balance);

				result.add(new PortfolioBalanceDTO(balance,portfolioResultValues,portfolioBalanceValues));
			}
			return ok(result);
		}
		switch (type.toLowerCase()){
			case "open":
				//bought
				List<PortfolioOpenDTO> openResult = new ArrayList<>();
				for (PortfolioBalance balance : jpa.selectPortfolioBalance(history, RawTransaction.TRANSACTION_RECORD_TYPE_BUY)) {
					List<PortfolioBalanceValue> portfolioBalanceValues = jpa.selectBalanceValuesByBalance(balance);

					PortfolioOpenDTO open = new PortfolioOpenDTO(balance,portfolioBalanceValues);
					openResult.add(open);
				}
				return ok(openResult);

			case "sold":
				//sold

				List<PortfolioSoldDTO> result = new ArrayList<>();
				for (PortfolioBalance balance : jpa.selectPortfolioBalance(history, RawTransaction.TRANSACTION_RECORD_TYPE_SELL)) {
					List<PortfolioResultValue> portfolioResultValues = jpa.selectResultValuesByBalance(balance);

					PortfolioSoldDTO sold = new PortfolioSoldDTO(balance,portfolioResultValues);
					result.add(sold);
				}
				return ok(result);
			default:
				return error("Unknown type for balances: "+type);
		}
	}


	@GET
	@Path("portfolio/{id}/history/")
	@Consumes(MediaType.APPLICATION_JSON)
	@Produces(MediaType.APPLICATION_JSON)
	public Response getHistories(@PathParam("id") long portfolioId, @QueryParam("typeDISABLED") String type, @QueryParam("from") Long from, @QueryParam("to") Long to) {
		System.out.println("FROM: "+from+"/ TO: "+to);
		/*if(type == null){
			return error("Missing type for balances request.");
		}*/

		Portfolio portfolio = jpa.selectByID(Portfolio.class,portfolioId);
		if(portfolio == null){
			return error("Portfolio "+portfolioId+" not found");
		}
		if(portfolio.getOrganization().getId()!=getUser().getPerson().getOrganization().getId()){
			System.out.println("portfolio "+portfolio.getOrganization().getId()+"/"+getUser().getPerson().getOrganization().getId());
			return error(401);
		}


		Date fromDate;
		Date toDate;
		if(from == null){
			Calendar now = Calendar.getInstance();
			now.add(Calendar.YEAR, -1);
			fromDate = now.getTime();
		}else{
			fromDate = new Date(from*1000);
		}
		if(to == null){
			toDate = new Date();
		}else{
			toDate = new Date(to*1000);
		}

		List<PortfolioHistory> histories = jpa.selectHistoriesFromToWithPortfolio(fromDate,toDate, portfolio);

		List<PortfolioHistoryDTO> historiesDTO = new ArrayList<>();
		for(PortfolioHistory history : histories) {
			if (type == null) {
				List<PortfolioBalanceDTO> balances = new ArrayList<>();
				for (PortfolioBalance balance : jpa.selectPortfolioBalance(history)) {
					List<PortfolioBalanceValue> portfolioBalanceValues = jpa.selectBalanceValuesByBalance(balance);
					List<PortfolioResultValue> portfolioResultValues = jpa.selectResultValuesByBalance(balance);

					balances.add(new PortfolioBalanceDTO(balance, portfolioResultValues, portfolioBalanceValues));
				}
				PortfolioHistoryDTO newHistory = new PortfolioHistoryDTO(history.getAt(),balances);
				historiesDTO.add(newHistory);
			}
		}
		return ok(historiesDTO);
	}

}