package main_package;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Serializable;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.time.LocalDate;
import java.time.Period;
import java.util.ArrayList;
import java.util.Date;

import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;


import org.primefaces.json.JSONArray;
import org.primefaces.json.JSONObject;

@ManagedBean(name="manageMandateBean")
@ViewScoped
public class manageMandate implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private NachMandateData selectedData; 
	private String  searchType="all";
	private  boolean cancelmandate;
	private String selectedRefId;
	private String markSelectedRefId;

	

	
	
	ArrayList<NachMandateData> natchDataList= new ArrayList<>();
	private String Authorization,key_id,key_secret,url,callbackUrl,redirectUrl;

	
	public manageMandate() {
		
		fetchReqsFromStatus();
	}
	
	
	public void fetchReqsFromStatus() {
	    String criteria;
	    if (searchType == null || searchType.trim().isEmpty()) {
	        criteria = "all";
	    } else {
	        criteria = searchType;
	    }

	    
	    String query;

	    if ("pending".equals(criteria)) {
	        query = "select * from nach_mandate_request where status='pending'";
	        fetchNatchData(query);
	        cancelmandate = false;
	    } else if ("approved".equals(criteria)) {
	        query = "select * from nach_mandate_request where status='approved'";
	        fetchNatchData(query);
	        cancelmandate = true;
	    } else if ("cancelled".equals(criteria)) {
	        query = "select * from nach_mandate_request where status='cancelled'";
	        fetchNatchData(query);
	        cancelmandate = false;
	    } else if ("all".equals(criteria)) {
	        query = "select * from nach_mandate_request";
	        fetchNatchData(query);
	        cancelmandate = false;
	    } else {
	        query = "select * from nach_mandate_request";
	        fetchNatchData(query);
	        cancelmandate = false;
	    }

	    FacesContext fc = FacesContext.getCurrentInstance();
	    if (fc != null) {
	        fc.addMessage(null, new FacesMessage(
	            FacesMessage.SEVERITY_INFO,
	            "Search completed"+
	            "Found " + (natchDataList == null ? 0 : natchDataList.size()) + " record(s).",null));
	    }
	}
	

	 
	 public void fetchApiDetailsDB() {
	    	
	    	try(Connection conn=DataBaseConnection.JAVAConnection()){
	    		
	    		String query = "SELECT * FROM api_keys WHERE id = ? LIMIT 1";
	    		try(PreparedStatement psmt=conn.prepareStatement(query)){
	    		    psmt.setInt(1, 2);

	    			ResultSet rs=psmt.executeQuery();
	    			while(rs.next()) {
	    				url=rs.getString("url");
	    				Authorization=rs.getString("authorization");
	    				key_id=rs.getString("keyid");
	    				key_secret=rs.getString("keySecret");
	    				
	    			}
	    			
	    			
	    		}catch (Exception e) {
	    			e.printStackTrace();
				}
	    	}catch (Exception e) {
				e.printStackTrace();
			}
	    }

	 public void markMandateCancel() {
		    if (markSelectedRefId == null || markSelectedRefId.trim().isEmpty()) {
		        
		    	  FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR,
				    "Invalid request.",
				    "No Mandate Reference ID provided."));
		        return ; // stay on the same page
		    }

		    int updateRes = updateMandateAsCancelled(markSelectedRefId);

		    if (updateRes > 0) {
		    	  FacesContext.getCurrentInstance().addMessage(null,
		            new FacesMessage(FacesMessage.SEVERITY_INFO,
		                "Mandate cancellation initiated successfully.",
		                "Reference ID: " + markSelectedRefId));
		    	  
		    	  fetchReqsFromStatus();
		    } else {
		    	  FacesContext.getCurrentInstance().addMessage(null,
		            new FacesMessage(FacesMessage.SEVERITY_WARN,
		                "Cancellation initiated, but local DB not updated.",
		                "Reference ID: " + markSelectedRefId));
		    }
		    
		    return ; 
		}

		public void cancelMandate() {
			
			fetchApiDetailsDB();
	    	boolean isValid = validateFields(url, callbackUrl, redirectUrl, Authorization, key_id, key_secret);

			if (!isValid) {	
			    FacesContext.getCurrentInstance().addMessage(null, 
			    	    new FacesMessage(
			    	        FacesMessage.SEVERITY_ERROR, 
			    	        "Some problem while fetching API credentials from DB."+ 
			    	        "If you use this service, please contact support.",null
			    	    )
			    	);
			} else {
				 cancelMandateMain(selectedRefId);
				
			}
		  
		}
	 
		
		private static boolean isNullOrEmpty(String str) {
			
			  return (str == null || str.trim().isEmpty());
		
		}
		
		public static boolean validateFields(String url, String callbackUrl, String redirectUrl,
		                                   String authorization, String key_id, String key_secret) {
		  if (isNullOrEmpty(url)) return false;
		  if (isNullOrEmpty(callbackUrl)) return false;
		  if (isNullOrEmpty(redirectUrl)) return false;
		  if (isNullOrEmpty(authorization)) return false;
		  if (isNullOrEmpty(key_id)) return false;
		  if (isNullOrEmpty(key_secret)) return false;
		
		  return true;
		}

	 public void cancelMandateMain(String merchantTrxnRefId) {
		   
		    if (merchantTrxnRefId == null || !merchantTrxnRefId.matches("^[A-Za-z0-9]{16,30}$")) {
		        FacesContext.getCurrentInstance().addMessage(null,
		            new FacesMessage(FacesMessage.SEVERITY_ERROR,
		                "Invalid merchantTrxnRefId (must be 16–30 alphanumeric).", null));
		        return;
		    }

		    HttpURLConnection connection = null;
		    try {
		        String urlStr = url + URLEncoder.encode(merchantTrxnRefId, StandardCharsets.UTF_8);
		        URL url = new URL(urlStr);
		        
		        connection = (HttpURLConnection) url.openConnection();
		        connection.setRequestMethod("POST");
		        connection.setReadTimeout(10000);
		        connection.setConnectTimeout(15000);
		        connection.setRequestProperty("Content-Type", "application/json");
		        connection.setRequestProperty("Accept", "application/json");
		        connection.setRequestProperty("Authorization", Authorization.trim());
		        
		        connection.setRequestProperty("key-id", key_id.trim());
		        connection.setRequestProperty("key-secret", key_secret.trim());
		        
		        connection.setDoOutput(false);
		        
		        int responseCode = connection.getResponseCode();
		        
		        try (BufferedReader reader = new BufferedReader(new InputStreamReader(
		                responseCode > 299 ? connection.getErrorStream() : connection.getInputStream(),
		                StandardCharsets.UTF_8))) {

		            StringBuilder content = new StringBuilder();
		            String line;
		            while ((line = reader.readLine()) != null) {
		                content.append(line);
		            }
		            
		            if (content.length() == 0) {
		                FacesContext.getCurrentInstance().addMessage(null,
		                        new FacesMessage(FacesMessage.SEVERITY_ERROR,
		                                "Empty response from cancelMandate API.", null));
		                return;
		            }
		            	
		           
		            
		            JSONObject jsonResponse = new JSONObject(content.toString());
		            String status = jsonResponse.optString("status");
		            String code = jsonResponse.optString("code");
		            String description = jsonResponse.optString("description");

		            FacesContext facesContext = FacesContext.getCurrentInstance();

		            if (("Success".equalsIgnoreCase(status) || "0x0200".equals(code))) {
		              
		                int updateRes = updateMandateAsCancelled(merchantTrxnRefId);
		                if (updateRes > 0) {
		                    facesContext.addMessage(null,
		                        new FacesMessage(FacesMessage.SEVERITY_INFO,
		                            "Mandate cancellation initiated successfully.", description));
		                } else {
		                    facesContext.addMessage(null,
		                        new FacesMessage(FacesMessage.SEVERITY_WARN,
		                            "Cancellation initiated, but local DB not updated.", null));
		                }
		            } else if ("BAD_REQUEST".equalsIgnoreCase(status)
		                    && jsonResponse.has("description")
		                    && jsonResponse.get("description") instanceof JSONArray) {

		                JSONArray errors = jsonResponse.getJSONArray("description");
		                for (int i = 0; i < errors.length(); i++) {
		                    String errorMessage = errors.getString(i);
		                    facesContext.addMessage(null,
		                        new FacesMessage(FacesMessage.SEVERITY_ERROR,
		                            "Cancel Validation Error: " + errorMessage, null));
		                }

		            } else {
		                facesContext.addMessage(null,
		                    new FacesMessage(FacesMessage.SEVERITY_ERROR,
		                        "Cancel mandate failed: " + (description != null ? description : "Unknown Error")
		                        + (code != null ? " (Code: " + code + ")" : ""), null));
		            }
		        }

		    } catch (IOException e) {
		        e.printStackTrace();
		        new DataBaseMethods().fileCreation(e.getMessage());
		        FacesContext.getCurrentInstance().addMessage(null,
		            new FacesMessage(FacesMessage.SEVERITY_ERROR,
		                "I/O Error calling cancelMandate: " + e.getMessage(), null));
		    } finally {
		        if (connection != null) {
		            connection.disconnect();
		        }
		    }
		}

	
	 public int updateMandateAsCancelled(String merchantTrxnRefId) {
		 String query = "UPDATE nach_mandate_request SET  status = ?  WHERE merchant_trxn_ref_id = ?";
	        try (Connection conn = DataBaseConnection.JAVAConnection();
	             PreparedStatement ps = conn.prepareStatement(query)) {
	            
	            ps.setString(1, "cancelled");
	            ps.setString(2, merchantTrxnRefId);

	            int rows = ps.executeUpdate();
	            System.out.println("Mandate status updated. Rows affected: " + rows);
	            return rows;
	        } catch (Exception e) {
	            System.err.println("Error updating mandate status:");
	            e.printStackTrace();
	            
	        }
	        return 0;
	}


	public void fetchNatchData(String query) {
	        natchDataList = new ArrayList<>();
  int i=1;
	        try (Connection conn = DataBaseConnection.JAVAConnection()) {
	            try (PreparedStatement psmt = conn.prepareStatement(query)) {
	                ResultSet rs = psmt.executeQuery();

	                while (rs.next()) {
	                    NachMandateData req = new NachMandateData();

	                    req.setSno(i++);
	                    req.setId(rs.getInt("id"));
	                    req.setCustomerName(rs.getString("customer_name"));
	                    req.setMobile(rs.getString("mobile"));
	                    req.setEmail(rs.getString("email"));
	                    req.setAccountNumber(rs.getString("account_number"));
	                    req.setIfsc(rs.getString("ifsc"));
	                    req.setBankCode(rs.getString("bank_code"));
	                    req.setAuthType(rs.getString("auth_type"));
	                    req.setMandateAmount(rs.getDouble("mandate_amount"));
	                    req.setCollectionAmount(rs.getDouble("collection_amount"));
	                    req.setStartDate(rs.getDate("start_date"));
	                    req.setEndDate(rs.getDate("end_date"));
	                    String duration = getYearMonthDifference(req.getStartDate(), req.getEndDate());
	                 //   System.out.println("Duration: " + duration);
	                     req.setTenure(duration);

	                    req.setFrequency(rs.getString("frequency"));
	                    req.setRedirectUrl(rs.getString("redirect_url"));
	                    req.setCallbackUrl(rs.getString("callback_url"));
	                    req.setMerchantTrxnRefId(rs.getString("merchant_trxn_ref_id"));
	                    req.setUmrn(rs.getString("umrn"));
	                    req.setStatus(rs.getString("status"));
	                    req.setEntryDate(rs.getTimestamp("entry_date"));
	                    req.setUpdatedAt(rs.getTimestamp("updated_at"));
	                    req.setUserId(rs.getString("user_id"));
	                    req.setLoanNo(rs.getString("loan_no"));

	                    natchDataList.add(req);
	                }

	            } catch (Exception e) {
	                e.printStackTrace();
	            }

	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	    }

	 public static String getYearMonthDifference(Date sqlStartDate, Date sqlEndDate) {
		    if (sqlStartDate == null || sqlEndDate == null) {
		        return "Invalid dates";
		    }

		    LocalDate startDate = ((java.sql.Date) sqlStartDate).toLocalDate();
		    LocalDate endDate = ((java.sql.Date) sqlEndDate).toLocalDate();

		    Period period = Period.between(startDate, endDate);

		    int years = period.getYears();
		    int months = period.getMonths();

		    // Add 1 month for inclusive counting
		    if (!startDate.isAfter(endDate)) {
		        months += 1;

		        // Fix: convert >=12 months into years
		        if (months >= 12) {
		            years += months / 12;
		            months = months % 12;
		        }
		    }

		    StringBuilder result = new StringBuilder();

		    if (years > 0) {
		        result.append(years).append(" year");
		        if (years > 1) result.append("s");
		        result.append(" ");
		    }

		    if (months > 0) {
		        result.append(months).append(" month");
		        if (months > 1) result.append("s");
		    }

		    if (result.length() == 0) {
		        result.append("0 months");
		    }

		    return result.toString().trim();
		}


	public ArrayList<NachMandateData> getNatchDataList() {
		return natchDataList;
	}




	public void setNatchDataList(ArrayList<NachMandateData> natchDataList) {
		this.natchDataList = natchDataList;
	}

	public void viewDetails(NachMandateData data) {
	    this.selectedData = data;
	}




	public NachMandateData getSelectedData() {
		return selectedData;
	}




	public void setSelectedData(NachMandateData selectedData) {
		this.selectedData = selectedData;
	}


	public String getSearchType() {
		return searchType;
	}


	public void setSearchType(String searchType) {
		this.searchType = searchType;
	}


	public boolean isCancelmandate() {
		return cancelmandate;
	}


	public void setCancelmandate(boolean cancelmandate) {
		this.cancelmandate = cancelmandate;
	}
	
	 public void setSelectedRefId(String selectedRefId) {
		    this.selectedRefId = selectedRefId;
		}


	public String getMarkSelectedRefId() {
		return markSelectedRefId;
	}


	public void setMarkSelectedRefId(String markSelectedRefId) {
		this.markSelectedRefId = markSelectedRefId;
	}


	

}