# Chargement des packages necessaires
library(quantmod)  # Pour le telechargement des donnees financieres
library(dplyr)     # Pour la manipulation des donnees (arrange, mutate, lag)

#################################################
# MODULE 1: Acquisition et traitement des donnees
#################################################

# Fonction pour telecharger les donnees du CAC 40
get_cac40_data <- function(days_back = 180) {
  date_fin <- Sys.Date()
  date_debut <- date_fin - days_back
  
  # Telechargement des donnees
  cac40 <- getSymbols("^FCHI", src = "yahoo", 
                      from = date_debut, 
                      to = date_fin, 
                      auto.assign = FALSE)
  
  # Extraction des prix de cloture
  cac40_close <- Cl(cac40)
  colnames(cac40_close) <- "CAC40"
  
  # Conversion en data frame
  cac40_df <- data.frame(
    Date = index(cac40_close),
    Prix = as.numeric(cac40_close)
  )
  
  return(cac40_df)
}

# Fonction pour calculer la volatilite
calculate_volatility <- function(price_data) {
  # Calcul des rendements journaliers
  data_with_returns <- price_data %>%
    arrange(Date) %>%
    mutate(Rendement = (Prix / lag(Prix) - 1) * 100)
  
  # Calcul de la volatilite
  volatilite_journaliere <- sd(data_with_returns$Rendement, na.rm = TRUE)
  volatilite_annuelle <- volatilite_journaliere * sqrt(252)  # 252 jours de trading
  
  # Retourner les resultats
  return(list(
    data = data_with_returns,
    current_price = tail(data_with_returns$Prix, 1),
    daily_vol = volatilite_journaliere,
    annual_vol = volatilite_annuelle,
    sigma = volatilite_annuelle / 100  # Conversion en decimal
  ))
}

#################################################
# MODULE 2: Modele Black-Scholes
#################################################

# Fonction Black-Scholes pour evaluer les options
black_scholes <- function(S, K, r, T, sigma, type = "call") {
  # Calcul des parametres
  d1 <- (log(S/K) + (r + sigma^2/2) * T) / (sigma * sqrt(T))
  d2 <- d1 - sigma * sqrt(T)
  
  # Calcul du prix selon le type d'option
  if (type == "call") {
    prix <- S * pnorm(d1) - K * exp(-r * T) * pnorm(d2)
  } else {
    prix <- K * exp(-r * T) * pnorm(-d2) - S * pnorm(-d1)
  }
  
  return(prix)
}

#################################################
# MODULE 3: Calcul des Grecques
#################################################

# Delta - sensibilite au prix du sous-jacent
delta <- function(S, K, r, T, sigma, type = "call") {
  d1 <- (log(S/K) + (r + sigma^2/2) * T) / (sigma * sqrt(T))
  
  if (type == "call") {
    return(pnorm(d1))
  } else {
    return(pnorm(d1) - 1)
  }
}

# Gamma - taux de variation du delta
gamma <- function(S, K, r, T, sigma) {
  d1 <- (log(S/K) + (r + sigma^2/2) * T) / (sigma * sqrt(T))
  return(dnorm(d1) / (S * sigma * sqrt(T)))
}

# Vega - sensibilite a la volatilite
vega <- function(S, K, r, T, sigma) {
  d1 <- (log(S/K) + (r + sigma^2/2) * T) / (sigma * sqrt(T))
  return(S * dnorm(d1) * sqrt(T) / 100)  # /100 pour % de volatilite
}

# Theta - sensibilite au temps
theta <- function(S, K, r, T, sigma, type = "call") {
  d1 <- (log(S/K) + (r + sigma^2/2) * T) / (sigma * sqrt(T))
  d2 <- d1 - sigma * sqrt(T)
  
  if (type == "call") {
    return((-S * dnorm(d1) * sigma / (2 * sqrt(T)) - 
              r * K * exp(-r * T) * pnorm(d2)) / 365)  # Valeur quotidienne
  } else {
    return((-S * dnorm(d1) * sigma / (2 * sqrt(T)) + 
              r * K * exp(-r * T) * pnorm(-d2)) / 365)  # Valeur quotidienne
  }
}

#################################################
# MODULE 4: Calcul de la Volatilite Implicite
#################################################

implied_volatility <- function(market_price, S, K, r, T, type = "call", 
                               tol = 1e-5, max_iter = 100) {
  # Valeur initiale de la volatilite
  sigma <- 0.2
  
  for (i in 1:max_iter) {
    # Prix calcule avec la volatilite actuelle
    price <- black_scholes(S, K, r, T, sigma, type)
    
    # Difference entre prix du marche et prix calcule
    diff <- market_price - price
    
    # Condition d'arret
    if (abs(diff) < tol) {
      return(sigma)
    }
    
    # Calcul du vega pour la mise a jour
    vega_value <- vega(S, K, r, T, sigma) * 100
    
    # Mise a jour de la volatilite (methode de Newton)
    sigma <- sigma + diff / vega_value
    
    # Eviter les valeurs negatives
    if (sigma <= 0) sigma <- 0.001
  }
  
  warning("Convergence non atteinte apres ", max_iter, " iterations")
  return(sigma)
}

#################################################
# UTILISATION DU CODE
#################################################

# Exemple d'utilisation du code
run_analysis <- function() {
  # 1. Acquisition des donnees
  cac40_data <- get_cac40_data(180)
  
  # 2. Calcul de la volatilite
  vol_results <- calculate_volatility(cac40_data)
  
  # 3. Parametres de l'option
  S <- vol_results$current_price  # Prix actuel
  K <- 8100                       # Prix d'exercice
  r <- 0.03                       # Taux d'interet sans risque (3%)
  T <- 3/12                       # Echeance (3 mois)
  sigma <- vol_results$sigma      # Volatilite
  
  # 4. Calcul des prix d'options
  prix_call <- black_scholes(S, K, r, T, sigma, "call")
  prix_put <- black_scholes(S, K, r, T, sigma, "put")
  
  # 5. Verification de la parite put-call
  parite <- prix_call + K * exp(-r * T) - prix_put - S
  
  # 6. Calcul des grecques
  delta_call_val <- delta(S, K, r, T, sigma, "call")
  delta_put_val <- delta(S, K, r, T, sigma, "put")
  gamma_val <- gamma(S, K, r, T, sigma)
  vega_val <- vega(S, K, r, T, sigma)
  theta_call_val <- theta(S, K, r, T, sigma, "call")
  theta_put_val <- theta(S, K, r, T, sigma, "put")
  
  # 7. Calcul de volatilite implicite (exemple avec un prix hypothetique)
  prix_marche_call <- 350  # Prix hypothetique
  vol_implicite <- implied_volatility(prix_marche_call, S, K, r, T)
  
  # 8. Affichage des resultats
  cat("\n----- RESULTATS DES OPTIONS SUR LE CAC 40 -----\n")
  cat("Prix actuel du CAC 40:", S, "\n")
  cat("Prix d'exercice (Strike):", K, "\n")
  cat("Temps jusqu'a l'echeance:", T*12, "mois\n")
  cat("Taux sans risque:", r*100, "%\n")
  cat("Volatilite annualisee:", vol_results$annual_vol, "%\n\n")
  cat("Prix de l'option d'achat (call):", round(prix_call, 2), "EUR\n")
  cat("Prix de l'option de vente (put):", round(prix_put, 2), "EUR\n")
  cat("Verification parite put-call (??? 0):", round(parite, 4), "\n\n")
  cat("------- GRECQUES -------\n")
  cat("Delta call:", round(delta_call_val, 4), "\n")
  cat("Delta put:", round(delta_put_val, 4), "\n")
  cat("Gamma:", round(gamma_val, 6), "\n")
  cat("Vega:", round(vega_val, 2), "pour 1% de volatilite\n")
  cat("Theta call:", round(theta_call_val, 2), "par jour\n")
  cat("Theta put:", round(theta_put_val, 2), "par jour\n\n")
  cat("------- VOLATILITE IMPLICITE -------\n")
  cat("Prix de marche call hypothetique:", prix_marche_call, "EUR\n")
  cat("Volatilite implicite calculee:", round(vol_implicite * 100, 2), "%\n")
  
  # 9. Retourner les resultats pour une utilisation ulterieure
  return(list(
    data = vol_results$data,
    params = list(S = S, K = K, r = r, T = T, sigma = sigma),
    prices = list(call = prix_call, put = prix_put, parity = parite),
    greeks = list(
      delta_call = delta_call_val,
      delta_put = delta_put_val,
      gamma = gamma_val,
      vega = vega_val,
      theta_call = theta_call_val,
      theta_put = theta_put_val
    ),
    implied_vol = vol_implicite
  ))
}

# Exécution de l'analyse
results <- run_analysis()

# Résultats obtenus:
#
# ----- RESULTATS DES OPTIONS SUR LE CAC 40 -----
# Prix actuel du CAC 40: 8028.28 
# Prix d'exercice (Strike): 8100 
# Temps jusqu'a l'echeance: 3 mois
# Taux sans risque: 3 %
# Volatilite annualisee: 14.09401 %
#
# Prix de l'option d'achat (call): 220.26 EUR
# Prix de l'option de vente (put): 231.46 EUR
# Verification parite put-call (??? 0): 0 
#
# ------- GRECQUES -------
# Delta call: 0.5062 
# Delta put: -0.4938 
# Gamma: 0.000705 
# Vega: 16.01 pour 1% de volatilite
# Theta call: -1.55 par jour
# Theta put: -0.89 par jour
#
# ------- VOLATILITE IMPLICITE -------
# Prix de marche call hypothetique: 350 EUR
# Volatilite implicite calculee: 22.2 %