# CalendarAPI.py
# FLEXSCHEアドイン用
import clr
clr.AddReference('FLEXSCHE.Interop.AIM')
clr.AddReference('FLEXSCHE.Interop.SData')
clr.AddReference('FLEXSCHE.Interop.GUI')
clr.AddReference('FLEXSCHE.Interop.SDLib')
clr.AddReference('FLEXSCHE.Interop.FSEditor')
clr.AddReference('FLEXSCHE.Interop.GPEns')
clr.AddReference('FLEXSCHE.Net')
clr.AddReference('PyLib')
from FLEXSCHE.Interop import AIM, SData, GUI, SDLib, FSEditor, GPEns
from FLEXSCHE.XmlHelper import *
from PyLib import Script
# googleカレンダーapi
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
# インポート
import datetime
import os.path
import inspect
import time
import datetime
import json

# ------------------------ パラメータ ------------------------
# スコープ. アクセス権を指定できる(読み込み、書き込みの許可)
# 変えたらtoken.jsonを消す
SCOPES = ["https://www.googleapis.com/auth/calendar"]

# クエリごとのsleep時間(秒, 小数可)
# apiを大量に呼ばないようにするため
WAITING_TIME = 0.5 

# トークン、カレンダーid等
# token, credentials, calendarをコードと同じ階層に置く
token_path = os.path.join(os.path.dirname(__file__), "token.json")
creds_path = os.path.join(os.path.dirname(__file__), "credentials.json")
calendar_path = os.path.join(os.path.dirname(__file__), "calendar.json")
__Calendars = {}

#　タイムゾーンの設定
# 東京の場合
# 'dateTime': '2025-05-28T09:00:00+09:00', 末尾に+9:00を追加する(offset_timezone)
# 'timeZone': 'Asia/Tokyo',
timezone = "Asia/Tokyo"
offset_timezone = "+09:00"
# -----------------------------------------------------------

class FLEXSCHEData:
  def __init__(self, keyEntity: AIM.KeyEntity) -> None:
    self.env = Script.Cast(keyEntity.get_ParamObject(int(GUI.ParamIDType.ParamIDEnvironment)), GUI.Environment)
    self.project: GUI.Project = self.env.Project
    self.ds: SData.SDSpace = Script.Cast(self.project.DataSpace, SData.ISDSpace)
    self.ut: SDLib.SDLUtility = Script.Cast(self.ds.SDLUtility, SDLib.ISDLUtility)

# デバッグ用
def alert(msg: any) -> None:
  Script.ShowMessageBox(str(msg), "FLEXSCHE", AIM.MessageBoxType.MBTOk)

# カレンダーid(json)を読み込む
def InitCalendar(is_first: bool = True) -> None:
  if is_first:
    global __Calendars
    if calendar_path != '':
      with open(calendar_path, encoding="utf-8_sig") as f:
        __Calendars = json.load(f)
    is_first = False

# recourcecodeのカレンダーidを取得(なければ空文字列)
def GetCalendarId(rescode: str) -> str:
  InitCalendar()
  if rescode in __Calendars:
    return __Calendars[rescode]
  else:
    return ""

# calendaridのresidを取得(複数ある場合初めに見つけたやつを返す. なければ空文字列)
def GetResId(calendarid: str) -> str:
  InitCalendar()
  for k, v in __Calendars.items():
    if v == calendarid:
      return k
  return ""

# カレンダー(の参照)を取得
def GetAllCalendars() -> map:
  InitCalendar()
  return __Calendars

# tokenをチェックしてcredsを返す
def CheckToken():
  creds = None
  if os.path.exists(token_path):
    creds = Credentials.from_authorized_user_file(token_path, SCOPES)
  if not creds or not creds.valid:
    if creds and creds.expired and creds.refresh_token:
      creds.refresh(Request())
    else:
      flow = InstalledAppFlow.from_client_secrets_file(creds_path, SCOPES)
      creds = flow.run_local_server(port=0)
    with open(token_path, "w") as token:
      token.write(creds.to_json())
  time.sleep(WAITING_TIME)
  return creds

# 20250528T090000 -> 2025-05-28T09:00:00
def InsertHyphen(s: str) -> str:
  return s[0:4] + '-' + s[4:6] + '-' + s[6:8] + 'T' + s[9:11] + ':' + s[11:13] + ':00'

# 2025-05-28T09:00:00 -> 20250528T090000
def DeleteHyphen(s: str) -> str:
  return s[0:4] + s[5:7] + s[8:13] + s[14:16]

# FLEXSCHE時間 -> GoogleCalendar時間
def ToGoogleTime(data: FLEXSCHEData, T: float) -> str:
  S = str(data.ut.TimeToISO8601(T))
  assert len(S) != 0
  if len(S) < 13:
    S += 'T0000'
  return InsertHyphen(S) + offset_timezone

# GoogleCalendar時間 -> FLEXSCHE時間
def ToFlexscheTime(data: FLEXSCHEData, T: str) -> float:
  return data.ut.TimeFromISO8601(DeleteHyphen(T))

# 全てのイベントを自由カレンダーとして取り込む (成功したか返す)
def ImportSchedulesAsFreeCalendars(data: FLEXSCHEData, calendarid: int) -> bool:
  creds = CheckToken()
  try:
    service = build("calendar", "v3", credentials=creds)
    events = service.events().list(calendarId=calendarid).execute()["items"]
    rescode = GetResId(calendarid)
    res = data.ds.ResourceSet.get_ResourceRecByCode(rescode)
    for event in events:
      Ts = event['start']['dateTime'] if 'dateTime' in event['start'] else event['start']['date'] + 'T00:00:00' + offset_timezone
      Ts = ToFlexscheTime(data, Ts)
      Te = event['end']['dateTime'] if 'dateTime' in event['end'] else event['end']['date'] + 'T00:00:00' + offset_timezone
      Te = ToFlexscheTime(data, Te)
      rr = data.ds.FreeCalendarSet.CreateFreeCalendarRec(SData.SDFreeCalendarType.SDFCTypeAssociatedToTimeSeries, True)
      rr.set_StartTime(Ts)
      rr.set_Duration(Te - Ts)
      rr.ResourceRec = res
      rr.set_Comment('name', event['summary'] if 'summary' in event else '無題のイベント')
      time.sleep(WAITING_TIME)
    return True
  except HttpError as error:
    return False

# color = {0:資源ごと, 1:オーダーごと, 2:工程ごと}
def GetColor(op: SData.SDataType.SDTypeOperation, res: SData.SDataType.SDTypeResource, color: int) -> int:
  ans = -1
  if color == 0:
    ans = hash(res.Code)
  elif color == 1:
    ans = hash(op.SingleOrderRec.Code)
  elif color == 2:
    ans = hash(op.Specifier)
  else:
    ans = 0 # colorが無効な値なら資源ごとにする
  return (ans + 2) % 12

# リスト中の作業を全て追加(成功したか返す)
def AddAllEvents(data: FLEXSCHEData, ops: list, color: int = 0) -> bool:
  creds = CheckToken()
  try:
    service = build("calendar", "v3", credentials=creds)
    for op in ops:
      for i in range(op.CountOfTaskRecs):
        task = op.get_TaskRec(i)
        if task.IsAssigned == 0:
          continue
        Ts = ToGoogleTime(data, task.AssignmentStartTime)
        Te = ToGoogleTime(data, task.AssignmentEndTime)

        # direction = {0:作業追加時から未来方向に, 1:作業開始前から過去方向に}
        # offset(>=0)分動かした時刻に通知  
        def AddReminder(event: map, direction: bool, offset: int) -> None:
          assert offset >= 0
          if direction == False:
            Tn = datetime.datetime.now(datetime.timezone(datetime.timedelta(hours=9)))
            Sdiff = (datetime.datetime.fromisoformat(Ts) - Tn).total_seconds() - offset * 60
            # 過去には通知しない
            if Sdiff < 0:
              return
            event['reminders']['overrides'].append({
              'method': 'popup',
              'minutes': Sdiff // 60
            })
          else:
            event['reminders']['overrides'].append({
              "method": 'popup',
              "minutes": offset
            })

        # 場所を設定
        def SetPlace(event: map, place: str) -> None:
          event['location'] = place

        # 説明を設定
        def SetDetail(event: map, detail: str) -> None:
          event['description'] = detail

        event = {
          'summary': op.Code,
          'start': {
            'dateTime': Ts,
            'timeZone': timezone,
          },
          'end': {
            'dateTime': Te,
            'timeZone': timezone,
          },
          'colorId': GetColor(op, task.AssignedResourceRec, color),
          'reminders': {
            'useDefault': False,
            'overrides': []
          }
        }
        AddReminder(event, False, 0) # 作業登録時に通知
        AddReminder(event, True, 1) # 作業開始1分前に通知
        SetPlace(event, op.ProcRec.get_Comment('場所')) # 工程マスタのコメント:場所を登録
        SetDetail(event, op.ProcRec.get_Comment('説明')) # 工程マスタのコメント:場所を登録
        event = service.events().insert(calendarId=GetCalendarId(task.AssignedResourceRec.Code), body=event).execute()
        time.sleep(WAITING_TIME)
    return True
  except HttpError as error:
    return False

# 指定した作業を追加(成功したか返す)
def AddEvent(data: FLEXSCHEData, op: SData.SDataType.SDTypeOperation, color: int = 0) -> bool:
  return AddAllEvents(data.ut, [op], color)

# calendaridの全てのイベントを削除(成功したか返す)
def DeleteAllEvents(calendarid: str) -> bool:
  creds = CheckToken()
  try:
    service = build("calendar", "v3", credentials=creds)
    events = service.events().list(calendarId=calendarid).execute()["items"]
    for event in events:
      eventid = event['id']
      service.events().delete(calendarId=calendarid, eventId=eventid).execute()
      time.sleep(WAITING_TIME)
    return True
  except HttpError as error:
    return False

# 指定したイベントを削除 (成功したか返す)
def DeleteEvent(calendarid: str, event: map) -> bool:
  creds = CheckToken()
  try:
    service = build("calendar", "v3", credentials=creds)
    eventid = event['id']
    service.events().delete(calendarId=calendarid, eventId=eventid).execute()
    return True
  except HttpError as error:
    return False

# RegisterSchedule.py
from CalendarAPI import *

def SelfRegistration(addIns: AIM.AddIns):
  addin = addIns.AddScript("RegisterSchedule", int(GUI.AddInKeyType.AddInKeyMenuHelp))
  addin.MenuString = "全予定登録"
  addin.Order = 1

def RegisterSchedule(keyEntity: AIM.KeyEntity):
  data = FLEXSCHEData(keyEntity)
  opset = data.ds.OperationSet
  ops = []
  for i in range(opset.CountOfRecords):
    ops.append(opset.get_OperationRec(i))
  ok = AddAllEvents(data, ops, 1)
  if ok:
    alert("登録に成功しました")
  else:
    alert("登録に失敗しました")
  return True