import boto3

# S3 を操作する client を生成
s3 = boto3.client('s3')

# 未使用のバケット名を下記シングルクォートの中に入力してください
# ただし personalize という文言を必ずふくめてください
# ↓↓↓↓↓↓↓↓↓↓ 入力 ↓↓↓↓↓↓↓↓↓↓
bucket_name='<Enter the bucket name to be created>'
# ↑↑↑↑↑↑↑↑↑↑ 入力 ↑↑↑↑↑↑↑↑↑↑

# 東京リージョンにバケットを作成
s3.create_bucket(
    Bucket=bucket_name,
    CreateBucketConfiguration={'LocationConstraint': 'ap-northeast-1'}
)

import json

# 作成したバケットのバケットポリシーを操作
bucket_policy = boto3.resource('s3').BucketPolicy(bucket_name)

# ポリシーを dict で直書き
policy = {
    'Version': '2012-10-17',
    'Id': 'PersonalizeS3Bucket AccessPolicy',
    'Statement': [
        {
            'Sid': 'PersonalizeS3BucketAccessPolicy',
            'Effect': 'Allow',
            'Principal': {
                'Service': 'personalize.amazonaws.com'
            },
            'Action': [
                's3:GetObject',
                's3:PutObject',
                's3:ListBucket'
            ],
            'Resource': [
                'arn:aws:s3:::' + bucket_name,
                'arn:aws:s3:::' + bucket_name +'/*'
            ]
        }
    ]
}

# ポリシーを json に変換
policy = json.dumps(policy)

# ポリシーを設定
response = bucket_policy.put(
    Policy=policy
)

iam = boto3.client('iam')

# Personalize でロールを引き受けられるよう Assume Role Document を直書き
assume_role_policy_document = {
    'Version': '2012-10-17',
    'Statement': [{'Sid': '','Effect': 'Allow','Principal': {'Service': 'personalize.amazonaws.com'},'Action': 'sts:AssumeRole'}]
}

# ロールを作成
response = iam.create_role(
    RoleName = 'MenuPersonalizeRole',
    AssumeRolePolicyDocument = json.dumps(assume_role_policy_document),
    MaxSessionDuration=3600*12 # 12時間
)

# 後で使えるよう、ロールの名前とロールの Arn を変数に格納
role_arn = response['Role']['Arn']
role_name = response['Role']['RoleName']

# AmazonPersonalizeFullAccessを作成したロールにアタッチ
response = iam.attach_role_policy(RoleName=role_name,PolicyArn='arn:aws:iam::aws:policy/service-role/AmazonPersonalizeFullAccess')

# interaction と item を csv 形式に出力
interaction_out_df.to_csv('interaction.csv',index=False)
item_out_df.to_csv('item.csv',index=False)

# S3 にアップロード
s3.upload_file('./interaction.csv', bucket_name, 'interaction.csv')
s3.upload_file('./item.csv', bucket_name, 'item.csv')

# Amazon Personalize の Client インスンタンスを生成。この client インスタンスが持つメソッドを利用して Amazon Personalize を操作する。
personalize = boto3.client('personalize')

# スキーマ定義
interaction_schema = {
    'type': 'record',
    'name': 'Interactions',
    'namespace': 'com.amazonaws.personalize.schema',
    'fields': [
        {
            'name': 'USER_ID',
            'type': 'string'
        },
        {
            'name': 'ITEM_ID',
            'type': 'string'
        },
        {
            'name': 'TIMESTAMP',
            'type': 'long'
        }
    ],
    'version': '1.0'
}

# スキーマ作成
create_interaction_schema_response = personalize.create_schema(
    name = 'menu-interaction-schema',
    schema = json.dumps(interaction_schema)
)

# スキーマの識別子(Arn)を変数に格納
interaction_schema_arn = create_interaction_schema_response['schemaArn']

# 結果確認
print(json.dumps(create_interaction_schema_response, indent=2))

# スキーマ定義
item_schema = {
    'type': 'record',
    'name': 'Items',
    'namespace': 'com.amazonaws.personalize.schema',
    'fields': [
        {
            'name': 'ITEM_ID',
            'type': 'string'
        },
        {
            'name': 'GENRE',
            'type': ['string','null'],
            'categorical': True
        }
    ],
    'version': '1.0'
}

# スキーマ作成
create_item_schema_response = personalize.create_schema(
    name = 'menu-item-schema',
    schema = json.dumps(item_schema)
)

# スキーマの識別子(Arn)を変数に格納
item_schema_arn = create_item_schema_response['schemaArn']

# 結果確認
print(json.dumps(create_item_schema_response, indent=2))

import time
# データセットグループの作成
create_dataset_group_response = personalize.create_dataset_group(
    name = 'menu-dataset-group'
)

# データセットグループの識別子(Arn)を変数に格納
dataset_group_arn = create_dataset_group_response['datasetGroupArn']
print(json.dumps(create_dataset_group_response, indent=2))

# データセットグループの状況を確認する
status = None
max_time = time.time() + 3*60*60 # 3 hours
while time.time() < max_time:
    # 処理の状況を確認する
    describe_dataset_group_response = personalize.describe_dataset_group(
        datasetGroupArn = dataset_group_arn
    )
    status = describe_dataset_group_response['datasetGroup']['status']
    
    # 処理が終わっていたら結果を表示してループを抜ける
    if status == 'ACTIVE' or status == 'CREATE FAILED':
        print('!')
        print(f'CreateDatasetGroup: {status}')
        break
    
    # 処理が進行中の場合は、sleep を挟んでループする
    else: 
        print('.',end='')
        time.sleep(1)

# Interaction Data のデータセット作成
interaction_dataset_type = 'Interactions'
create_interaction_dataset_response = personalize.create_dataset(
    datasetType = interaction_dataset_type, # データセットのタイプ
    datasetGroupArn = dataset_group_arn, # データセットグループの識別子(Arn)
    name = 'menu-interactions', # データセットの一意な名前
    schemaArn = interaction_schema_arn # 使用するスキーマの識別子(Arn)
)

# データセットの識別子(Arn)を変数に格納
interaction_dataset_arn = create_interaction_dataset_response['datasetArn']

# 結果確認
print(json.dumps(create_interaction_dataset_response, indent=2))


# Item Data のデータセット作成
item_dataset_type = 'Items'
create_item_dataset_response = personalize.create_dataset(
    datasetType = item_dataset_type,
    datasetGroupArn = dataset_group_arn,
    name = 'menu-item',
    schemaArn = item_schema_arn
)

# データセットの識別子(Arn)を変数に格納
item_dataset_arn = create_item_dataset_response['datasetArn']

# 結果確認
print(json.dumps(create_item_dataset_response, indent=2))

# Interaction Data インポートジョブ
create_interaction_dataset_import_job_response = personalize.create_dataset_import_job(
    jobName = 'menu-interaction-dataset-import-job', # 一意なインポートジョブの名前
    datasetArn = interaction_dataset_arn,
    dataSource = {
        'dataLocation': f's3://{bucket_name}/interaction.csv' # インポートする csv のURI
    },
    roleArn = role_arn # インポートジョブを実行するロールの識別子（Arn)
)

# Interaction Data インポートジョブの識別子(Arn)を変数に格納
interaction_dataset_import_job_arn = create_interaction_dataset_import_job_response['datasetImportJobArn']

# Interaction Data インポートジョブのメソッドの返り値を確認
print(json.dumps(create_interaction_dataset_import_job_response, indent=2))


# Item Data インポートジョブ
create_item_dataset_import_job_response = personalize.create_dataset_import_job(
    jobName = 'menu-item-dataset-import-job',
    datasetArn = item_dataset_arn,
    dataSource = {
        'dataLocation': f's3://{bucket_name}/item.csv'
    },
    roleArn = role_arn
)

# Item Data インポートジョブの識別子(Arn)を変数に格納
item_dataset_import_job_arn = create_item_dataset_import_job_response['datasetImportJobArn']
# Item Data インポートジョブのメソッドの返り値を確認
print(json.dumps(create_item_dataset_import_job_response, indent=2))

# Interaction Data インポートジョブの完了待機
status = None
max_time = time.time() + 3*60*60 # 3 hours
while time.time() < max_time:
    describe_dataset_import_job_response = personalize.describe_dataset_import_job(
        datasetImportJobArn = interaction_dataset_import_job_arn
    )
    
    dataset_import_job = describe_dataset_import_job_response['datasetImportJob']
    status = dataset_import_job['status']
    
    if status == 'ACTIVE' or status == 'CREATE FAILED':
        print('!')
        print(f'LatestDatasetImportJobRun: {status}')
        break
    else:
        print('.',end='')
        
    time.sleep(60)

# Item Data インポートジョブの完了待機
status = None
max_time = time.time() + 3*60*60 # 3 hours
while time.time() < max_time:
    describe_dataset_import_job_response = personalize.describe_dataset_import_job(
        datasetImportJobArn = item_dataset_import_job_arn
    )
    
    dataset_import_job = describe_dataset_import_job_response['datasetImportJob']
    status = dataset_import_job['status']
    
    if status == 'ACTIVE' or status == 'CREATE FAILED':
        print('!')
        print(f'LatestDatasetImportJobRun: {status}')
        break
    else:
        print('.',end='')
        
    time.sleep(5)

list_recipes_response = personalize.list_recipes()
recipe_arns = {}
for recipe in list_recipes_response['recipes']:
    recipe_arns[recipe['recipeArn'].split('/')[-1]] = recipe['recipeArn']
for key in recipe_arns.keys():
    print(key + ' -> ' + recipe_arns[key])

# aws-user-personalization を用いたソリューションの作成
user_personalization_create_solution_response = personalize.create_solution(
    name = 'menu-user-personalization', # ソリューションの一意な名前
    datasetGroupArn = dataset_group_arn, #  使用するデータセットグループの識別子
    recipeArn = recipe_arns['aws-user-personalization']) # aws-user-personalization レシピの識別子

# solution の識別子(Arn)を変数に格納
user_personalization_solution_arn = user_personalization_create_solution_response['solutionArn']
# 結果確認
print(json.dumps(user_personalization_create_solution_response, indent=2))

# ソリューションバージョンの作成
user_personalization_create_solution_version_response = personalize.create_solution_version(
    solutionArn=user_personalization_solution_arn
)
# ソリューションバージョンの識別子(Arn)を変数に格納
user_personalization_solution_version_arn = user_personalization_create_solution_version_response['solutionVersionArn']
# 結果確認
print(json.dumps(user_personalization_create_solution_version_response, indent=2))

# ソリューションバージョンの作成が完了するのを待つ
status = None
max_time = time.time() + 3*60*60 # 3 hours
while time.time() < max_time:
    describe_solution_version_response = personalize.describe_solution_version(
        solutionVersionArn = user_personalization_solution_version_arn
    )
    status = describe_solution_version_response['solutionVersion']['status']
    
    if status == 'ACTIVE' or status == 'CREATE FAILED':
        print('!')
        print(f'user-personalize solution version : {status}')
        break
    else:
        print('.',end='')
        
    time.sleep(60)

# キャンペーン の作成
create_user_personalization_campaign_response = personalize.create_campaign(
    name = 'menu-campaign-user-personalization',
    solutionVersionArn = user_personalization_solution_version_arn, # ソリューションバージョンの識別子(Arn)
    minProvisionedTPS = 1, # 1 秒間にさばける transaction の数
)

# キャンペーンの識別子(Arn)を変数に格納
user_personalization_campaign_arn = create_user_personalization_campaign_response['campaignArn']
# 結果確認
print(json.dumps(create_user_personalization_campaign_response, indent=2))

# 処理結果待ち
status = None
max_time = time.time() + 3*60*60 # 3 hours
while time.time() < max_time:
    describe_campaign_response = personalize.describe_campaign(
        campaignArn = user_personalization_campaign_arn
    )
    status = describe_campaign_response['campaign']['status']
    
    if status == 'ACTIVE' or status == 'CREATE FAILED':
        print('!')
        print(f'LatestDatasetImportJobRun: {status}')
        break
    else:
        print('.',end='')
        
    time.sleep(60)

# 稼働済みの Amazon Personalize のサービスを利用するためのpersonalize-runtime クライアントインスタンスを生成
personalize_runtime = boto3.client('personalize-runtime')

# レコメンド取得
get_recommendations_response = personalize_runtime.get_recommendations(
    campaignArn = user_personalization_campaign_arn,
    userId = '1'
)

# 結果確認
print(json.dumps(get_recommendations_response,indent=2))

import numpy as np
item_list = get_recommendations_response['itemList']
title_list = [item_df.loc[item_df['ITEM_ID'] == np.int(item['itemId'])].values[0][0] for item in item_list]
print(title_list[0],item_list[0])

# イベントトラッカーの作成
create_event_tracker_response = personalize.create_event_tracker(
    datasetGroupArn = dataset_group_arn,
    name = 'menu-event-tracker'
)

# イベントトラッカーの識別子(Arn)を変数に格納
event_tracker_arn = create_event_tracker_response['eventTrackerArn']

# 結果確認
print(json.dumps(create_event_tracker_response, indent=2))

# 出来上がるまで待つ
status = None
max_time = time.time() + 3*60*60 # 3 hours
while time.time() < max_time:
    describe_event_tracker_response = personalize.describe_event_tracker(
        eventTrackerArn = event_tracker_arn
    )
    status = describe_event_tracker_response["eventTracker"]["status"]
    
    if status == "ACTIVE" or status == "CREATE FAILED":
        print('!')
        print(f'status:{status}')
        break
    print('.',end = '')
    time.sleep(5)

# イベントトラッカーの ID を変数に格納
tracking_id = create_event_tracker_response['trackingId']
print(f'tracking_id: {tracking_id}')

import uuid

personalize_events = boto3.client('personalize-events')
session_id = str(uuid.uuid4())

personalize_events.put_events(
    trackingId = tracking_id, # イベントトラッカーの ID
    userId = '1', # 私の USER_ID
    sessionId = session_id,  # Web システムなどでログイン前のデータと紐付けるときに使う。今回はなんでもいいのでユニークな値を入れる
    eventList = [
        {
            "sentAt": datetime.datetime(2021, 4, 1, 12, 0, 0, 0), # 日時を入れる
            "eventType": "RATING",
            "properties": json.dumps(
                {
                    'itemId': item_list[0]['itemId'] # 先程のレコメンド 1 位の ITEM_ID
                }
            )
        }
    ]
)

# レコメンド取得
get_recommendations_response = personalize_runtime.get_recommendations(
    campaignArn = user_personalization_campaign_arn,
    userId = '1'
)

# 結果確認
item_list = get_recommendations_response['itemList']
title_list = [item_df.loc[item_df['ITEM_ID'] == np.int(item['itemId'])].values[0][0] for item in item_list]
print(title_list[0],item_list[0])

# GENRE でフィルタするクエリを作成
filter_expression = 'INCLUDE ItemID WHERE Items.GENRE IN ($GENRE)'

# フィルタを作成
create_filter_response = personalize.create_filter(
    datasetGroupArn = dataset_group_arn,
    filterExpression = filter_expression,
    name = 'genre_filter_action'
)

# フィルタの識別子(Arn)を変数に格納
filter_arn = create_filter_response['filterArn']

# 結果確認
print(json.dumps(create_filter_response, indent=2))

# フィルタが出来上がるのを待つ
status = None
max_time = time.time() + 3*60*60 # 3 hours
while time.time() < max_time:
    describe_filter_response = personalize.describe_filter(
        filterArn = filter_arn
    )
    status = describe_filter_response["filter"]["status"]
    print('.',end='')
    
    if status == "ACTIVE" or status == "CREATE FAILED":
        print('!')
        print(f"Filter: {status}")
        break
        
    time.sleep(5)

# フィルタつきのレコメンド取得
get_recommendations_response = personalize_runtime.get_recommendations(
    campaignArn = user_personalization_campaign_arn,
    userId = '1',
    filterArn = filter_arn, # フィルタの識別子(Arn)
    filterValues={ "GENRE": "\"血圧注意\""} # 血圧注意のみに絞る
)

item_list = get_recommendations_response['itemList']
title_list = [item_df.loc[item_df['ITEM_ID'] == np.int(item['itemId'])].values[0][0] for item in item_list]

print(title_list[0],item_list[0])

# jsonlines モジュールの読み込み。必要に応じて pip install してください
import jsonlines

# 今回は私(USER_ID=1)のみレコメンド
user_list = []
user_list.append({"userId": "1"})

# json ファイルを書き込み
batch_inference_input_file_name = 'batch_infrence_input.json'
with jsonlines.open(batch_inference_input_file_name, mode='w') as writer:
    writer.write_all(user_list)

# S3 にアップロード
s3.upload_file(f'./{batch_inference_input_file_name}', bucket_name, batch_inference_input_file_name)

# バッチレコメンドジョブの作成
create_batch_inference_job_response = personalize.create_batch_inference_job (
    solutionVersionArn = user_personalization_solution_version_arn,
    jobName = "menu-batch-recommendation-job",
    roleArn = role_arn,
    jobInput = 
       {"s3DataSource": {"path": f's3://{bucket_name}/{batch_inference_input_file_name}'}},
    jobOutput = 
       {"s3DataDestination": {"path": f's3://{bucket_name}/batch-inference-output/'}},
    numResults = 100
)

# バッチレコメンドジョブの識別子(Arn)を変数に格納
batchInferenceJobArn = create_batch_inference_job_response['batchInferenceJobArn']

# 結果確認
print(json.dumps(create_batch_inference_job_response, indent=2))

# バッチレコメンドジョブの完了を待つ
status = None
max_time = time.time() + 3*60*60 # 3 hours
while time.time() < max_time:
    describe_batch_inference_job_response = personalize.describe_batch_inference_job(
        batchInferenceJobArn = batchInferenceJobArn
    )
    status = describe_batch_inference_job_response["batchInferenceJob"]["status"]
    
    if status == "ACTIVE" or status == "CREATE FAILED":
        print('!')
        print(f"status: {status}")
        break
    else:
        print('.',end='')
        time.sleep(60)

# ファイル名
batch_inference_file_name = 'batch_infrence_input.json.out'
# S3 の URI を取得
output_path = describe_batch_inference_job_response['batchInferenceJob']['jobOutput']['s3DataDestination']['path'] + batch_inference_file_name
# ダウンロード
s3.download_file(bucket_name, '/'.join(output_path.split('/')[3:]), batch_inference_file_name)

with open(batch_inference_file_name,'rt') as f:
    data = json.loads(f.read())
print(item_df.loc[item_df['ITEM_ID'] == int(data['output']['recommendedItems'][0])]['料理名'].values[0],data['output']['recommendedItems'][0],data['output']['scores'][0])